关于 java 继承的哪些事

引言

本文结合一个例子来说明继承实现的基本原理。

基类 Base 代码如下所示：

public class Base {
    public static int s;
    private int a;
    static {
        System.out.println("基类静态代码块，s:"+s);
        s=1;
    }
    {
        System.out.println("基类实例代码块，a:"+a);
        a=1;
    }
    public Base(){
        System.out.println("基类构造方法，a:"+a);
        a=2;
    }
    protected void step(){
        System.out.println("base s:"+s+",a:"+a);
    }
    public void action(){
        System.out.println("start");
        step();
        System.out.println("end");
    }
}

注意： Base 包含一个静态变量 s，一个实例变量 a，一段静态初始化代码块，一段实例初始化代码块，一个构造方法，两个方法 step 和 action。

子类 Child 代码如下所示：

public class Child extends Base{
    public static int s;
    private int a;
    static {
        System.out.println("子类静态代码块,s:"+s);
        s=10;
    }
    {
        System.out.println("子类实例代码块,a:"+a);
        a=10;
    }
    public Child(){
        System.out.println("子类构造方法，a:"+a);
        a=20;
    }

    @Override
    protected void step() {
        System.out.println("child s:"+s+",a:"+a);
    }
}

注意： 子类 Child 继承了 Base，也定义了和基类同名的静态变量 s 和实例变量 a 并且重写了方法 step。

测试的 main 方法代码如下所示:

public static void main(String[] args) {
    System.out.println("------------- new Child()");
    Child c=new Child();
    System.out.println("\n-- c.action");
    c.action();
    Base b=c;
    System.out.println("\n --- b.action()");
    System.out.println("\n --- b.s:"+b.s);
    System.out.println("\n --- c.s:"+c.s);
    }

执行结果如下：

下边我们逐过程来解释下其背后发生了什么，并解释我们所提出的问题。

类的加载过程

在 java 中，所谓的类加载指的是将类的相关信息加载到内存中。在 java 中类是动态加载的，当第一次使用这个类的时候才会加载，而且在加载一个类的时候会查看其父类是否被加载，如果没有则会加载其父类。

一个类的信息主要包含以下几个部分：

类的加载过程顺序如下：

1. 分配内存保存类的信息

2. 给类变量赋默认值

   注意： 数字类变量默认值都是 0，boolean 默认值是 false，char 是 \u0000，引用型变量默认值都是 null。

3. 加载父类

4. 设置父子关系

5. 执行类的初始化代码

以我们的例子来说，我们这里有三份类信息，分别是 Child、Base、Object，内存布局如下图所示：

对象的创建过程

在类加载之后，new Child()就会创建 Child 对象，创建 Child 对象过程包括：

1. 分配内存
2. 对所有实例变量赋默认值
3. 执行实例初始化代码

在该部分分配的内存包括本类和所有父类的实例变量，不包含任何静态变量（因为类加载过程中这部分变量的内存已经分配完成）。实例的初始化代码执行先从父类开始，父类执行完成之后再执行子类。但需要注意的是在任何类执行初始化代码之前，任何实例变量都会被赋默认值。

但需要注意的是，每一个对象除了保存类的实例变量之外，还保存着实际类信息的引用。

方法调用的过程

在该部分我们分析前边所提出的问题，首先我们先来看 c.action()，这句代码的执行过程如下：

1. 查看 c 的对象类型，找到 Child 类型，在 Child 类中找 action 方法，发现没有然后到父类中寻找。
2. 在父类 Base 中找到了方法 action，开始执行 action 方法；
3. action 先输出 start，然后发现需要调用 step()方法，就从 Child 类型中去寻找 step()方法；
4. 在 Child 类型中找到了 Child 方法，执行 Child 类中的 step()方法，输出 Child 类中的两个变量 s(=10),a(=20)的值；
5. 继续执行 action 方法输出 end

在此处我们可以发现，寻找要执行的实例方法的时候，是从对象的实际类型信息开始查找的，找不到的时候在查找父类的类型信息。

接着我们来看 b.action()的执行过程，这句话实际上输出的结果和 c.aciton()方法输出的结果是一样的，这我们称之为 动态绑定，而 动态绑定 实现的机制就是根据对象的实际类型信息查找要执行的方法，子类型中查找不到才会查找父类。这里因为 b 和 c 执行的是相同的对象，所有执行的结果是一样的。

而对于变量部分我们发现，其访问过程是 静态绑定 的，即无论对于类变量还是实例变量访问的时候，访问的实际变量都和其对象类的类型绑定，如 b.s 和 c.s 分别访问的是 Base.s 和 Child.s。例子中实例变量都是 private 类型的，如果是 public 我们会发现 b.a 访问的是 Base 类定义的实例变量 a，而 c.a 访问的是对象中 Child 类定义的实例变量 a。

小结

在该部分我们分析的类和对象加载的过程，以及在过程中方法和代码块的执行顺序，我们可以得到以下结论。

方法和代码的执行顺序：

1. 父类的类初始化代码块（static 代码块）
2. 子类的类代码初始化块
3. 父类的实例初始化代码块
4. 父类的构造方法
5. 子类的实例初始化代码块
6. 子类的构造方法

重载方法的执行逻辑：

寻找要执行的实例方法的时候，是从对象的实际类型信息开始查找的，找不到的时候在查找父类的类型信息。