Java的继承

复用代码是 Java 众多引人注目的功能之一，但是想成为一门极具革命性的语言，仅仅能够复制代码并加以改变是远远不够的，它必须能够做更多的事情。

继承语法

继承无处不在，每当创建一个类的时候，就已经在继承了，因为，除非明确指出要从其他类中继承，否则所有的类都从隐式地从根类 Object 类中进行继承。

继承通过关键字 extends 实现，子类会自动获取父类中所有的成员和方法。我们先创建一个父类：

public class Pet {

    private String name = "Tom";

    public void play() {
        System.out.println("play method");
    }

    public String getName() {
        return name;
    }
}

再创建一个子类：

public class Cat extends Pet {

    public void play() {
        System.out.println(getName());
        //调用父类的 play 方法
        super.play();
    }
}

由于父类的成员变量 name 是 private 修饰，所以可以通过 getName() 方法来获取 name 属性。在子类方法 play() 中，不能直接调用 play() 方法，这样做会产生递归（自己调用自己），所以引用 super 关键字来表示 play() 方法是从父类中继承来的。

父类初始化

从外部来看，子类就像是一个与父类具有相同接口的新类，也许会增加一些成员或方法，但是继承并不只是复制父类的接口。当创建一个新的子类对象时，这个对象就已经包含了一个父类的子对象，这个子对象与直接用父类创建的对象时一样的。区别在于，父类的子对象被包装在子类对象的内部，直接用父类创建的对象来自于外部。

我们先创建一个父类 People：

public class People {

    public People() {
        System.out.println("people constructor");
    }
}

再创建一个继承 People 的子类 Chinese :

public class Chinese extends People {

    public Chinese() {
        System.out.println("chinese constructor");
    }
}

再创建一个继承 Chinese 的子类 Student :

public class Student extends Chinese {

    public Student() {
        System.out.println("student constructor");
    }

    public static void main(String[] args) {
        new Student();
    }
}

运行 Student 类的 main 方法，打印结果如下：

people constructor
chinese constructor
student constructor

我们可以看到，构建过程是从父类开始然后逐渐向外扩散，所以父类在子类构造器可以访问它之前，就已经完成初始化了，即使没有创建 Student() 构造器，编译器也会合成一个默认的构造器，这个构造器将调用父类的构造器。

带参数的父类初始化

以上的构造器都是无参的，我们来看看带参的：

public class People {

    private String name;
    
    //有参构造器
    public People(String name) {
        System.out.println("people constructor, name:" + name);
    }
}


public class Chinese extends People {

    public Chinese(String name) {
        super(name);
        System.out.println("chinese constructor, name:" + name);
    }
}

public class Student extends Chinese {

    public Student(String name) {
        super(name);
        System.out.println("student constructor, name:" + name);
    }

    public static void main(String[] args) {
        new Student("Tom");
    }
}

运行 main 方法，看打印结果：

people constructor, name:Tom
chinese constructor, name:Tom
student constructor, name:Tom

我们可以看到如果没有默认的父类构造器，或者想调用一个带参的父类构造器，就必须使用关键字 super 来调用父类的构造器，并且要配上参数列表。

父类的 static 初始化

我们知道 Java 的所有事物都是对象，每个类只有在初次使用的时候才会加载，通常是指在创建第一个对象的时候发生加载，但是在访问 static 修饰的变量或者方法的时候，也会发生加载，并且加载的顺序就是程序中的顺序，static 的成员或者方法只会被加载一次。我们下面来看看带有 static 关键字的子父类加载过程：

先看看父类：

public class Insect {

    private int i = 1;
	
    private static int j = 2;

    {
        System.out.println("insect code block");
    }

    static {
        System.out.println("insect static code block, j = " + j);
    }


    public Insect() {
        System.out.println("insect constructor");
    }
}

然后再看看子类：

public class Butterfly extends Insect {

    private int m = 11;

    private static int n = 22;

    {
        System.out.println("Butterfly code block");
    }

    static {
        System.out.println("Butterfly static vode bolock, n = " + n);
    }


    public Butterfly() {
        System.out.println("Butterfly constructor");
    }

    public static void main(String[] args) {
        new Butterfly();
    }
}

打印结果如下：
insect static code block, j = 2
Butterfly static vode bolock, n = 22
insect code block
insect constructor
Butterfly code block
Butterfly constructor

所以我们看到加载顺序如下：

父类静态代码块（属性）—> 子类静态代码块（属性）—> 父类非静态代码块（属性） —> 父类构造器 —> 子类非静态代码块（属性）—> 子类构造器

欢迎关注公众号：一盐难进