Day12 Java学习第十二天--->继承
继承
1.继承的本质是对某一批类的抽象，从而实现对显示世界更好的建模
2.extends的意思是扩展，子类是父类的扩展
3.java中类只有单继承，没有多继承
4.继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
5.继承关系的两个类。一个为子类(派生类),一个为父类(基类)。子类继承父类，使用关键子extends来表时
6.子类和父类之间，从意义上讲应该有 is a 的关系
object类
super
方法重写
ctrl+H--->打开一个继承树(继承关系)
super注意点
-
super调用父类的构造方法，必须在构造方法的第一个
-
super必须只能出现在子类的方法或者构造方法中
-
super和this不能同时调用构造方法
VS this：
代表的对象不同：
this:本身调用者这个对象
super:代表父类对象的应用
前提：
this:没继承也可以使用
super:只能在继承条件才可以使用
构造方法：
this()：本类的构造
super():父类的构造
Person.java
//Teacher is 人 派生类：子类
public class Person {
//一个类内部要是什么都不写，它也会存在一个方法
String name;
int age;
public int money = 10000;
//实例化
public Person() {
System.out.println("Person 无参");
}
public Person(String name) {
this.name = name;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void say(){
System.out.println("人说了一句话");
}
public void print(){
System.out.println("Person");
}
}
Student.java
//学生类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
//封装大多数情况是针对属性而来的，对方法使用很少
//属性私有，即使外部去new对象时，也不可以使用了，
//所以就用提供了一些public操作属性的set()/get()
//名字
public String name;
//学号
private int id;
//性别
private char sex;
private int age;
public Student() {
//隐藏代码，调用父类的无参构造函数
super();//调用父类的构造器，必须要在子类构造器的第一行
System.out.println("Student 无参");
}
//方法
//get
//alt+insert
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120){
System.out.println("您设置的年龄过大");
}else{
this.age = age;
}
}
//学习()
//public static void say()
public void say(){
System.out.println("学生说话了");
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
public void print(){
System.out.println("student");
}
public void test1( ){
print();
this.print();
super.print();
}
}
ApplicationDemo1.java
public class ApplicationDemo1 {
public static void main(String[] args) {
Student s1 = new Student();
s1.say();
// Person p1 = new Person();
// p1.say();
// //s1.money;
// System.out.println(s1.money);
// s1.test("CAT");
// s1.print();
// s1.test1();
}
}
重写
重写都是方法的重写和属性无关
有了继承关系以后，父类的引用指向了子类(类之间是可以进行转换，你们有血缘关系，你们是父子)
方法的调用只和左边，定义的数据类型有关(跟右边的类无关)
A a = new A();
a.test();//A
父类引用指向子类
B b = new A();
b.test();//B
静态方法和非静态方法有巨大区别
静态方法与左边有关，与重写无关(静态方法在类的时候就创建了)
Application.java-- 主函数
public class Application{
public static void main(String[] args) {
A a = new A();
a.test();
B b = new A();
b.test();
}
}
A.java-- 父类
class B{
public static void test(){
System.out.println("B.test()");
}
}
B.java-- 子类
class A extends B{
public static void test(){
System.out.println("A.test()");
}
}
得出结果
A.test()
B.test()
非静态方法与重写有关，重写的关键词是public不可以是private,子类与父类有继承关系，才能重写
Application.java-- 主函数
public class Application{
public static void main(String[] args) {
A a = new A();
a.test();
B b = new A();
b.test();
}
}
A.java-- 父类
class B{
public void test(){
System.out.println("B.test()");
}
}
B.java-- 子类
class A extends B{
public void test(){
System.out.println("A.test()");
}
}
得出结果
A.test()
A.test()
重写的总结
1.1 方法名必须相同
1.2 参数列表必须相同
1.3 修饰符范围可以扩大，但不能缩小public>protected>default>private
1.4 重写抛出的异常，也是有范围的，可以被缩小，不能被扩大 classNotFountException > Exception大
重写：子类方法与父类方法，必须要一致
2.为什么需要重写？
2.1 子类不一定满足父类功能
浙公网安备 33010602011771号