21- 继承的基本知识

继承的主要作用：抽取共性

对于一个已经使用了的类，最好不要修改，推荐定义一个新的类，来重复利用其中的共性内容，并且添加改动内容。

定义父类格式:(这里假设父类没有更上层的父类)
 

public class 父类名称

{
    ...
}

定义子类格式：

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

一、在父子类继承关系当中，如果成员变量重名，则创建子类对象时，有两种访问方式：

1、直接通过子类对象访问成员变量，等号左边是谁，优先用谁，没有则向上找。

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

//Father.java
public class Father {
    int faNum = 10;
    int num = 11;

    public void method()
    {
        System.out.println("父类method!");
    }
}

//Son.java
public class Son extends Father{
    int sonNum = 20;
    int num = 21;
}

//DemoExample.java
public class DemoExample {
    public static void main(String[] args) {
        Son one = new Son();

        System.out.println(one.sonNum);//子类独有，用子类
        System.out.println(one.faNum);//子类没有，向上找父类
        System.out.println(one.num);//父类、子类都有，由于等号左边是子类，所有使用子类

        Father two = new Father();
        System.out.println(two.num);//等号左边是父类的，所以使用父类
    }
}

二、在子类的方法中，如果存在局部变量、子类成员变量、父类成员变量同名时，如何使用？

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

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

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

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

创建的对象时谁（new的是谁），就优先使用谁的方法，如果子类没有该方法就向上找父类看有没有。

四、在父子类继承关系中，关于方法重写注意事项

1、子类可以重写（override）父类的方法，但是需要名称一样，参数列表一样。

2、在子类的重写方法前面最好加@override，这样可以防止重写方法写错告警。

3、子类的返回值必须【小于等于】父类的返回值范围

小扩展：java.lang.object类时所有类的公共最高父类，java.Lang.String就是它的子类

4、子类方法的权限必须【大于等于】父类方法的权限修饰词

小扩展：修饰词public > protected > (default) > private

备注：（default）不是关键字，而是什么都不写。

注意重写和重载的区别

1、重写是名称和参数列表必须一致。

2、重载是名称一致，参数列表不能一致。

3、对于一个父类方法，如果子类重写了该方法，而又想使用父类该方法的功能，可以通过在子类方法中加入super.父类方法名称。

//父类包含方法
public void showMSG(){
       System.out.println("父类 showMSG");
}

//自乐你包含该方法
@Override
public void showMSG() {
        super.showMSG();
        System.out.println("子类showMSG");
 }

//如果执行子类的showMSG,则会打印如下：
父类 showMSG
子类showMSG

五、父子继承中关于构造方法的相关信息

1、子类构造方法中，有一个默认隐含调用super(),所以一定是先执行父类构造方法，再执行子类构造方法。

2、如果父类构造方法有重载，子类可以通过super(xxx)来选择使用哪个重载构造方法。

3、对父类构造函数的调用，必须放在子类构造函数的第一条执行语句，且只能调用一次。

4、子类如果写了对父类构造方法的调用super(xx),则不会赠送默认的，如果没有写则会默认赠送无参构造方法。但是如果父类重载了构造方法，但是没有写无参的构造方法，则子类必须写super(xx)（如果子类有重载构造方法，则每个构造方法都必须写）,原因你懂得！

六、super关键字的用法

1、在子类的成员方法中，访问父类的成员变量。

2、在子类的成员方法中，访问父类的成员方法。

3、在子类的构造方法中，访问父类的构造方法。

注意：

如果子类重载了构造方法，如果在某个构造方法中使用了this(...)，则在该构造方法中不能再使用super,当然就更会默认赠送。

且this也必须放在第一个执行语句，且也只能是唯一一个。

五、父子继承中关于构造方法的相关信息

//===========================================================
public class Father {
    private  int a;
    private  int b;

    //无参构造方法
    public Father() {
        System.out.println("父类无参构造方法");
    }

    //有参构造方法1
    public Father(int a) {
        this.a = a;
        System.out.println("父类有参构造方法1");
    }

    //有参构造方法2
    public Father(int a, int b) {
        this.a = a;
        this.b = b;
        System.out.println("父类有参构造方法2");
    }
}


//===========================================================
public class Son extends Father{
    private int x;
    private int y;

    public Son() {
        System.out.println("子类无参构造方法");
    }

    public Son(int x) {
        this.x = x;
        System.out.println("子类有参构造方法1");
    }

    public Son(int x, int y) {
        this.x = x;
        this.y = y;
        System.out.println("有参构造方法2");
    }
}

//=================================================================
public class Demo {
    public static void main(String[] args) {
        Son one = new Son();
    }

}

//=======================输出====================
父类无参构造方法
子类无参构造方法

//========================================================
public class Father {
    private  int a;
    private  int b;

    //无参构造方法
    public Father() {
        System.out.println("父类无参构造方法");
    }

    //有参构造方法1
    public Father(int a) {
        this.a = a;
        System.out.println("父类有参构造方法1");
    }

    //有参构造方法2
    public Father(int a, int b) {
        this.a = a;
        this.b = b;
        System.out.println("父类有参构造方法2");
    }
}

//========================================================
public class Son extends Father{
    private int x;
    private int y;

    public Son() {
        //super(10);
        this(10);
        System.out.println("子类无参构造方法");
    }

    public Son(int x) {
        this(10,1);
        this.x = x;
        System.out.println("子类有参构造方法1");
    }

    public Son(int x, int y) {
        super(10,10);
        this.x = x;
        this.y = y;
        System.out.println("有参构造方法2");
    }
}
//==================================================================
public class Demo {
    public static void main(String[] args) {
        Son one = new Son();
    }

}
//============================ 输出结果 ======================
父类有参构造方法2
有参构造方法2
子类有参构造方法1
子类无参构造方法