Java基础篇_继承

一、继承

1.1 继承的概念

继承是 Java 中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称子类(派生类)。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。例如：狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。

上述图示中，Dog 和 Cat 都继承了 Animal 类，其中：Animal 类称为父类/基类/超类，Dog 和 Cat 可以称为 Animal 的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。

class Animal {
    public String name;
    public int age;

    public void eat() {
        System.out.println(this.name + "在吃饭");
    }
}

class Dog extends Animal{
    public String color;
    
    public void barks() {
        System.out.println(this.name + "汪汪汪");
    }
}


public class Test {

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "毛球";
        dog.eat();//毛球在吃饭

    }
}

注：子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了。static修饰的成员变量或方法无法继承，因为是属于该类的。

1.3 访问父类成员

1.3.1 子类访问父类成员变量

1、不存在同名成员变量 

不存在同名成员变量时，在子类方法中访问成员变量时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

class Base {
    public int a;
    public int b;
}

class Derived extends Base{
    public int c;

    public void method(){
        System.out.println(a); // 访问从父类中继承下来的 a
        System.out.println(b); // 访问从父类中继承下来的 b
        System.out.println(c); // 访问子类自己的 c
    }
}

2、 存在同名成员变量 

class Base {
    public int a = 1;
    public int b = 2;
}

class Derived extends Base{
    public int a = 10;
    public int c = 3;

    public void method(){
        System.out.println(a); // 访问子类自己的 a ：10
        System.out.println(b); // 访问从父类中继承下来的 b ：2
        System.out.println(c); // 访问子类自己的 c ： 3
    }
}

在子类方法中或者通过子类对象访问成员变量时：

1、如果访问的成员变量子类中有，优先访问自己的成员变量。

2、如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。

3、如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

1.3.2 子类访问父类成员方法

1、不存在同名成员方法

成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

class Base {
    public int a = 1;
    public int b = 2;

    public void test() {
        System.out.println("Base.test()");
    }
}

class Derived extends Base{
    public int a = 10;
    public int c = 3;

public void test2() {
    System.out.println("Derived.test()");
}

    public void method(){

        test();// Base.test()
        test2();// Derived.test()
    }
}

class Base {
    public int a = 1;
    public int b = 2;

    public void test() {
        System.out.println("Base.test()");
    }
}

class Derived extends Base{
    public int a = 10;
    public int c = 3;

    public void test(int a) {
        System.out.println(a);
    }

    public void test2() {
    System.out.println("Derived.test()");
    }

    public void method(){

        test();// Base.test()
        test2();// Derived.test()
        test(10);// 10
}

在子类方法中或者通过子类对象访问成员方法时： 

1、通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。

2、通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同 (重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错。

1.4 super关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，直接访问是无法做到的，为此 Java 提供了 super 关键字，该关键字主要作用：在子类方法中访问父类的成员。

格式如下：

1、super.父类成员

2、super.父类成员方法

3、super() 父类的构造方法

class Base {
    public int a = 1;
    public int b = 2;
}

class Derived extends Base{
    public int a = 10;
    public int c = 3;

    public void method(){
        //自己有，访问自己的；自己没有，访问父类的
        System.out.println(super.a);// 1
        System.out.println(this.a);// 10
        System.out.println(super.b);// 2
        System.out.println(this.b);// 2
        System.out.println(this.c);// 3
    }
}

从上文代码中可以看出，在要输出的成员变量前面加上 super 关键字，即是在子类方法中访问父类的成员变量，this 是访问子类自己的成员变量，若子类中无该成员变量，则访问父类的。

【注意事项】

1、只能在非静态方法中使用。

2、用于在子类方法中，访问父类的成员变量和方法。

1.5 super和this

【相同点】

1、都是Java中的关键字。

2、只能在类的非静态方法中使用，用来访问非静态成员方法和字段。

3、在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在。

【不同点】

1、this 是当前对象的引用，当前对象即调用实例方法的对象，super 相当于是子类对象中从父类继承下来部分成员的引用。

2、在非静态成员方法中，this 用来访问本类的方法和属性，super 用来访问父类继承下来的方法和属性。

3、在构造方法中：this() 用于调用本类构造方法，super() 用于调用父类构造方法，两种调用不能同时在构造方法中出现。

4、构造方法中一定会存在 super() 的调用，用户没有写编译器也会增加，但是 this() 用户不写则没有。

1.6 子类构造方法

由于子类对象中成员是有两部分组成的，父类继承下来的以及子类新增加的部分。先有父再有子，所以在构造子类对象时候 ，要先调用父类的构造方法，将从父类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。

利用 super() 调用父类带有两个参数的构造方法来初始化父类成员，如下：

class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Dog extends Animal{
    public String color;

    public Dog(String name, int age, String color) {
        //调用父类带有两个参数的构造方法来初始化父类成员
        super(name, age);
        this.color = color;
    }
}
public class Test {

    public static void main(String[] args) {
        //产生子类对象的时候，父类的成员就要被初始化好
        Dog dog = new Dog("毛球",3, "金色");
        System.out.println(dog.name);// 毛球
        System.out.println(dog.age);// 3
        System.out.println(dog.color);// 金色
    }
}

1.7 继承方式

在现实生活中，事物之间的关系是非常复杂，灵活多样，比如：

但在 Java 中只支持以下三种继承方式（不支持多继承）：

1、单继承：一个类继承另一个类，例如：狗继承动物 。

2、多层继承：① 类继承 ② 类，② 类继承 ③ 类，例如：狗继承动物，哈士奇继承狗。

3、不同类继承同一个类：① 类和 ② 类都继承 ③ 类，例如：狗继承动物，猫也继承动物。

注：多层继承最好不要超过三层。

1.8 final关键字

1、final 修饰变量或字段时，表示常量 (不能修改) ，如下图，变量 a 被 fianl 修饰后再次赋值，则报错。

2、final 修饰类时，表示此类不能被继承，如下图，Person 类被 final 修饰后 Student 类想继承 Person 类，就发生了报错。

1.9 继承和组合

和继承类似，组合也是一种表达类之间关系的方式，也是能够达到代码复用的效果。组合并没有涉及到特殊的语法，仅仅是将一个类的实例作为另外一个类的字段。

举例：学校里面有若干学生和若干老师，这时有一个 Student 类和一个 Teacher 类，我们将他们写为 School 类的成员变量，以便其他类直接访问 School 类即可获得 Students 与 Teachers。

总结

 1、使用 extends 关键字实现继承，继承主要解决的问题是：共性的抽取，实现代码复用。

2、static 修饰的成员变量或方法无法继承，因为是属于该类的

3、成员变量与方法访问遵循就近原则，自己有优先自己的，如果没有则向父类中找

4、使用 super 关键字可以在子类方法中访问父类的成员，super 不能出现在 static 方法中

5、在子类构造方法中，super() 调用父类构造方法时，必须是子类构造函数中第一条语句 

6、在父类与子类的初始化中，运行顺序是父类静态、子类静态，再是父类实例、父类构造、子类实例、子类构造，其中静态块只会运行一次。