继承

继承

如果没有继承就没有多态。
师傅徒弟关系，每个徒弟会的一样。

继承主要解决的问题是：共性抽取。

继承关系的特点：
子类可以拥有父类的内容
子类还可以拥有自己专属的内容

在继承的关系中，”子类就是一个父类“，子类可以被看作父类
例如：父类是员工，子类是老师，那么“老师是员工”。

父类：

public class 父类名称{}

子类格式：

public class 子类 extends 父类{}

public class Demo01Extends {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        //Teacher虽然是空的，但会继承method方法
        teacher.method();
        Assistant ass = new Assistant();
        ass.method();//代码复用
    }
}

public class Assistant extends Employee{
}

public class Employee {
    public void method(){
        System.out.println("Run");
    }
}

public class Teacher extends Employee{
}

在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问规则是：

直接：直接通过子类对象访问成员变量
等号左边是谁，就优先用谁，没有就向上找。
zi.num 优先用子类，子类中没有，使用父类对象，到处都没有编译报错

间接：间接通过成员方法访问成员变量
方法属于谁，就优先用谁，没有就向上找

局部变量： 直接写
本类成员变量 this.变量
父类成员变量 super.变量

public class Demo02 {
    public static void main(String[] args) {
        Zi zi =new Zi();
        zi.method();
    }
}

public class Fu {
    int num = 10;
}

public class Zi extends Fu {
    int num = 20;
    public void method() {
        int num = 30;
        System.out.println(num);//30
        System.out.println(this.num);//20
        System.out.println(super.num);//10
    }
}

重写（override）–覆盖，覆写

重写:在继承关系中，方法名一样，参数列表也一样。
重载（overlord）
方法名称一样，参数列表不一样
方法覆写特点:创建的是子类对象，则优先使用子类方法。

Tip:
1必须保证父子类之间方法名相同，参数列表相同
@Override:写在方法前，用来检测是不是有效正确的覆盖重写

2子类方法的返回值必须小于等于父类方法返回值范围
前提：Object类是所有类的公共最高父类

Fu:
public Object method()
    return null;
}
Zi:
public void method(){
}

报错！！一个有返回值一个没有返回值

Zi:
public String method(){
    return null
}

正确！！

3子类方法的权限，必须大于等于父类方法的权限修饰符

public > protected > (default) > private
default不是关键字，而是什么都不写，留空。

继承关系中，父子类构造方法的访问特点：

1. 子类构造方法中有一个隐藏的super()调用，所以一定是先调用父类的构造方法，后子类
   super()调用父类无参构造方法
2. 子类构造可通过super关键字来调用父类重载构造
3. super的父类构造调用，必须是子类构造方法的第一个语句
4. 子类必须调用父类构造方法，不写则赠送super（），写了则用写了的super调用，super只能是一个，还必须是第一个

public class Demo1Constructor {
    public static void main(String[] args) {
        Zi zi = new Zi();
    }
}

public class Fu {
   public Fu(int a){
       System.out.println("Father num Run");
   }
   public Fu(){
       System.out.println("Father noNum Run");
   }
}

public class Zi extends Fu{
    public Zi(){
        super();
        //super(5);//error
        System.out.println("Son Run");
        //super();//error
    }
    public void method(){
        //super();//error
    }
}

super关键字的用法有三：

1. 在子类的成员方法中，访问父类的成员变量。
2. 在子类的成员方法中，访问父类的成员方法。
3. 在子类的构造方法中，访问父类的构造方法。

public class Demo {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.methodZi();
        zi.method();
    }
}

public class Fu {
    public Fu(){
        System.out.println("Fu");
    }
    int num = 10;
    public void method(){
        System.out.println("Father");
    }
}

public class Zi extends Fu{
    public Zi(){

    }
    int num = 20;
    public void methodZi(){
        System.out.println(super.num);
    }
    public void method(){
        super.method();
        System.out.println("Son");
    }
}

supper &this

super关键字用来访问父类的内容，this关键字用来访问本类内容
this用法有三：

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。

super() and this(),都得是第一个语句，所以不能同时使用。

public class Demo {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}

public class Fu {
    int num = 30;
}

public class Zi extends Fu {
    public Zi() {
        //super();
        this(123);//本类的无参构造，调用本类的有参构造
        //this(123);//error
        //this()调用也必须是构造方法的第一个语句,must first and only;
    }

    public Zi(int a) {

    }

    int num = 20;

    public void method() {
        int num = 10;
        System.out.println(num);//局部
        System.out.println(this.num);//成员变量
        System.out.println(super.num);//成员变量
    }

    public void methodA() {
        System.out.println("aaa");
    }

    public void methodB() {
        this.methodA();
    }
}

Tip:
1.Java语言是单继承的，一个类直接父类只能有一个。

2.Java语言可以多级继承，我有一个父亲，我的父亲也有一个父亲。

3.一个父类可以有很多个子类。