4.3 继承实现的基本原理

发表于 更新于 分类于 ， ， Waline： 本文字数： 4.1k 阅读时长 ≈ 4 分钟

4.3 继承实现的基本原理

本节通过一个例子来介绍继承实现的基本原理。需要说明的是，本节主要从概念上来介绍原理，实际实现细节可能与此不同。

4.3.1 示例

基类Base如代码清单4-7所示。

代码清单4-7 演示继承原理：Base类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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如代码清单4-8所示。

代码清单4-8 演示继承原理：Child类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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;
    }
    protected void step(){
        System.out.println("child s: " + s +", a: "+a);
    }
}

Child继承了Base，也定义了和基类同名的静态变量s和实例变量a，静态初始化代码块，实例初始化代码块，构造方法，重写了方法step。使用的例子如代码清单4-9所示。

代码清单4-9 演示继承原理：main方法
1
2
3
4
5
6
7
8
9
10
11
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()");
    b.action();
    System.out.println("\n---- b.s: " + b.s);
    System.out.println("\n---- c.s: " + c.s);
}

上面的代码创建了Child类型的对象，赋值给了Child类型的引用变量c，通过c调用action方法，又赋值给了Base类型的引用变量b，通过b也调用了action，最后通过b和c访问静态变量s并输出。这是屏幕的输出结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
---- new Child()
基类静态代码块， s: 0
子类静态代码块， s: 0
基类实例代码块， a: 0
基类构造方法， a: 1
子类实例代码块， a: 0
子类构造方法， a: 10
---- c.action()
start
child s: 10, a: 20
end
---- b.action()
start
child s: 10, a: 20
end
---- b.s: 1
---- c.s: 10

下面我们来解释一下背后都发生了一些什么事情，从类的加载开始。

4.3.2 类加载过程

在Java中，所谓类的加载是指将类的相关信息加载到内存。在Java中，类是动态加载的，当第一次使用这个类的时候才会加载，加载一个类时，会查看其父类是否已加载，如果没有，则会加载其父类。
1）一个类的信息主要包括以下部分：

  • 类变量（静态变量）；
  • 类初始化代码；
  • 类方法（静态方法）；
  • 实例变量；
  • 实例初始化代码；
  • 实例方法；
  • 父类信息引用。
    2）类初始化代码包括：
  • 定义静态变量时的赋值语句；
  • 静态初始化代码块。
    3）实例初始化代码包括：
  • 定义实例变量时的赋值语句；
  • 实例初始化代码块；
  • 构造方法。
    4）类加载过程包括：
  • 分配内存保存类的信息；
  • 给类变量赋默认值；
  • 加载父类；
  • 设置父子关系；
  • 执行类初始化代码。

注意，类初始化代码，是先执行父类的，再执行子类的。不过，父类执行时，子类静态变量的值也是有的，是默认值。对于默认值，我们之前说过，数字型变量都是0, boolean是false, char是’\u0000’，引用型变量是null。

之前我们说过，内存分为栈和堆，栈存放函数的局部变量，而堆存放动态分配的对象，还有一个内存区，存放类的信息，这个区在Java中称为方法区。

加载后，Java方法区就有了一份这个类的信息。以我们的例子来说，有3份类信息，分别是Child、Base、Object，内存布局如图4-3所示。

epub_923038_41

图4-3 继承原理：类信息内存布局

我们用class_init()来表示类初始化代码，用instance_init()表示实例初始化代码，实例初始化代码包括了实例初始化代码块和构造方法。例子中只有一个构造方法，实际情况则可能有多个实例初始化方法。

本例中，类的加载大致就是在内存中形成了类似上面的布局，然后分别执行了Base和Child的类初始化代码。接下来，我们看对象创建的过程。

4.3.3 对象创建的过程

在类加载之后，new Child()就是创建Child对象，创建对象过程包括：
1）分配内存；
2）对所有实例变量赋默认值；
3）执行实例初始化代码。

分配的内存包括本类和所有父类的实例变量，但不包括任何静态变量。实例初始化代码的执行从父类开始，再执行子类的。但在任何类执行初始化代码之前，所有实例变量都已设置完默认值。

每个对象除了保存类的实例变量之外，还保存着实际类信息的引用。

Child c = new Child()；会将新创建的Child对象引用赋给变量c，而Base b = c；会让b也引用这个Child对象。创建和赋值后，内存布局如图4-4所示。

epub_923038_42

图4-4 继承原理：对象内存布局

引用型变量c和b分配在栈中，它们指向相同的堆中的Child对象。Child对象存储着方法区中Child类型的地址，还有Base中的实例变量a和Child中的实例变量a。创建了对象，接下来，来看方法调用的过程。

4.3.4 方法调用的过程

我们先来看c.action(); ，这句代码的执行过程：
1）查看c的对象类型，找到Child类型，在Child类型中找action方法，发现没有，到父类中寻找；
2）在父类Base中找到了方法action，开始执行action方法；
3）action先输出了start，然后发现需要调用step()方法，就从Child类型开始寻找step()方法；
4）在Child类型中找到了step()方法，执行Child中的step()方法，执行完后返回action方法；
5）继续执行action方法，输出end。

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

我们来看b.action()，这句代码的输出和c.action()是一样的，这称为动态绑定，而动态绑定实现的机制就是根据对象的实际类型查找要执行的方法，子类型中找不到的时候再查找父类。这里，因为b和c指向相同的对象，所以执行结果是一样的。

如果继承的层次比较深，要调用的方法位于比较上层的父类，则调用的效率是比较低的，因为每次调用都要进行很多次查找。大多数系统使用一种称为虚方法表的方法来优化调用的效率。

所谓虚方法表，就是在类加载的时候为每个类创建一个表，记录该类的对象所有动态绑定的方法（包括父类的方法）及其地址，但一个方法只有一条记录，子类重写了父类方法后只会保留子类的。对于本例来说，Child和Base的虚方法表如图4-5所示。

epub_923038_43

图4-5 继承原理：虚方法表

对Child类型来说，action方法指向Base中的代码，toString方法指向Object中的代码，而step()指向本类中的代码。当通过对象动态绑定方法的时候，只需要查找这个表就可以了，而不需要挨个查找每个父类。接下来，我们介绍变量访问的过程。

4.3.5 变量访问的过程

对变量的访问是静态绑定的，无论是类变量还是实例变量。代码中演示的是类变量：b.s和c.s，通过对象访问类变量，系统会转换为直接访问类变量Base.s和Child.s。

例子中的实例变量都是private的，不能直接访问；如果是public的，则b.a访问的是对象中Base类定义的实例变量a，而c.a访问的是对象中Child类定义的实例变量a。

本节通过一个例子来介绍类的加载、对象创建、方法调用以及变量访问的内部过程。现在，我们应该对继承的实现有了比较清楚的理解。之前我们提到，继承是把双刃剑，为什么这么说呢？让我们下节来探讨。