Java--继承

1.继承

在继承的关系中，子类就是一个父类。也就是说，子类可以被当做父类看待。

例如父类是员工，子类是讲师，那么讲师就是一个员工。关系：is-a。

定义父类的格式:

public class 父类名称 {

     //...

}

定义子类的格式：

public class 子类名称 extends 父类名称 {

    //...

} 

//定义一个父类：员工
public class Employee {

    public void method(){
        System.out.println("方法执行了");
    }
}

// 定义了一个员工的子类：讲师
public class Teacher extends Employee {
}

//定义了员工的另一个子类：助教
public class Assistant extends Employee {
}

public class Demo01Extends {
    public static void main(String[] args) {
        //创建了一个子类对象
        Teacher teacher = new Teacher();
        // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。
        teacher.method();

        //创建另一个子类助教对象
        Assistant assistant = new Assistant();
        assistant.method();
    }
}

2.继承中成员变量的访问特点

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

（1）直接通过子类对象访问成员变量

等号左边是谁，就优先用谁，没有则向上找。

（2）间接通过成员方法访问成员变量

该方法属于谁，就优先用谁，没有则向上找。

public class Fu {
    int numFu = 10;
    int num =100;
    public void methodFu(){
        // 使用的是本类当中的，不会向下找子类的。
        System.out.println(num);
    }
}

public class Zi extends Fu {
    int numZi = 20;
    int num = 200;
    public void methodZi(){
        //因为本类当中有num,所以这里用的是本类的num
        System.out.println(num);
    }
}

public class Demo01ExtendsField {

    public static void main(String[] args) {
        Fu fu = new Fu();//创建父类对象
        System.out.println(fu.numFu);//只能使用父类的东西，没有任何子类的内容。
        System.out.println("==============");

        Zi zi = new Zi();
        System.out.println(zi.numFu);//10
        System.out.println(zi.numZi);//20
        System.out.println("==============");

        //等号左边是谁，就优先用谁
        System.out.println(zi.num);//优先子类：200
        System.out.println("==============");

        //这个方法是子类的，优先用子类的，如果没有再向上找。
        zi.methodZi();//200
        //这个方法是在父类当中定义的
        zi.methodFu();//100
    }
}

3.区分子类方法中重名的三种变量

局部变量： 直接写成员变量名

本类的成员变量： this.成员变量名

父类的成员变量： super.成员变量名

//定义父类
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 父类的成员变量
    }
}

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

        zi.method();
    }
}

4.继承中成员方法的访问特点

在父子类的继承关系当中，创建子类对象，访问成员方法的规则。

创建的对象是谁，就优先用谁，如果没有则向上找。

//创建父类
public class Fu {

    public void methodFu(){
        System.out.println("父类方法执行");
    }
    public void method(){
        System.out.println("父类重名方法执行！");
    }
}

//子类继承父类
public class Zi extends Fu {

    public void methodZi(){
        System.out.println("子类方法执行！");
    }

    public void method() {
        System.out.println("子类重名方法执行！");
    }
}

public class Demo01ExtendsMethod {

    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.methodZi();
        zi.methodFu();

        //创建的是new了子类对象，所以优先用子类方法。
        zi.method();
    }
}

输出结果：

 注意事项：

无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

重写（Override) 概念：在继承关系当中，方法的名称一样，参数列表也一样。覆盖、覆写。

重载（Overload）：方法的名称一样，参数列表不一样。

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

5.继承中方法的覆盖重写

public class Fu {

    public Object method(){
        return null;
    }
}

public class Zi extends Fu {

    @Override
    public String method(){
        return null;
    }
}

方法覆盖重写的注意事项：

（1）必须保证父子类之间方法的名称相同，参数列表也相同。

@Override : 写在方法前面，用来检测是不是有效的正确覆盖重写。

这个注解就算不写，主要满足要求，也是正确的方法覆盖重写。

（2）子类方法的返回值范围，必须小于等于父类方法的返回值范围。

java.lang.Object类是所有类的公共最高父类（祖宗类）；

Java.long.String就是Object的子类。

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

小扩展提示：public > protected > (default) > private

备注：(default)不是关键字default，而是什么都不写，留空。

应用场景：

//本来的老款手机
public class Phone {

    public void call(){
        System.out.println("打电话");
    }
    public void send(){
        System.out.println("发短信");
    }
    public void show(){
        System.out.println("显示号码");
    }
}

//定义一个新手机，使用老手机作为父类
public class NewPhone extends Phone {

    @Override
    public void show() {
//        System.out.println("显示号码");
        super.show();// 把父类的show方法拿过来重复利用
        //自己子类再来添加更多内容
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}

public class Demo01Phone {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.call();
        phone.send();
        phone.show();
        System.out.println("==============");

        NewPhone newPhone = new NewPhone();
        newPhone.call();
        newPhone.send();
        newPhone.show();
    }
}

输出结果：

 6.继承中构造方法的访问特点

 

public class Fu {

    public Fu(){
        System.out.println("父类无参构造方法");
    }
    public Fu(int num){
        System.out.println("父类有参构造");
    }
}

public class Zi extends Fu {

    public Zi(){
//        super();//在调用父类无参构造方法
        super(10);//在调用父类重载的构造方法
        System.out.println("子类构造方法");
    }
    public void method(){
//        super();
    }
}

public class Demo01Constructor {

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

输出结果：

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

（1）子类构造方法当中有一个默认隐含的super()调用，所以一定是先调用的父类构造方法，后执行的子类构造方法。

（2）子类构造可以通过super关键字来调用父类重载构造。

（3）super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

总结：

子类必须调用父类构造方法，不写则赠送super()。写了则用写的指定的super调用。super只能有一个，还必须是 第一个。