计算机程序的思维逻辑 (17) - 继承实现的基本原理

Posted 老马说编程

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了计算机程序的思维逻辑 (17) - 继承实现的基本原理相关的知识,希望对你有一定的参考价值。

本系列文章经补充和完善,已修订整理成书《Java编程的逻辑》,由机械工业出版社华章分社出版,于2018年1月上市热销,读者好评如潮!各大网店和书店有售,欢迎购买,京东自营链接http://item.jd.com/12299018.html


第15节我们介绍了继承和多态的基本概念,而上节我们进一步介绍了继承的一些细节,本节我们通过一个例子,来介绍继承实现的基本原理。需要说明的是,本节主要从概念上来介绍原理,实际实现细节可能与此不同。

例子

这是基类代码:

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。

这是子类代码:

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。

这是使用的代码:

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并输出。这是屏幕的输出结果:

---- 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

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

类的加载

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

一个类的信息主要包括以下部分:

  • 类变量(静态变量)
  • 类初始化代码
  • 类方法(静态方法)
  • 实例变量
  • 实例初始化代码
  • 实例方法
  • 父类信息引用 

类初始化代码包括:

  1. 定义静态变量时的赋值语句
  2. 静态初始化代码块

实例初始化代码包括:

  1. 定义实例变量时的赋值语句
  2. 实例初始化代码块
  3. 构造方法 

类加载过程包括:

  1. 分配内存保存类的信息
  2. 给类变量赋默认值
  3. 加载父类
  4. 设置父子关系
  5. 执行类初始化代码 

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

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

加载后,对于每一个类,在Java方法区就有了一份这个类的信息,以我们的例子来说,有三份类信息,分别是Child,Base,Object,内存示意图如下:

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

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

创建对象

在类加载之后,new Child()就是创建Child对象,创建对象过程包括:

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

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

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

Child c = new Child();会将新创建的Child对象引用赋给变量c,而Base b = c;会让b也引用这个Child对象。创建和赋值后,内存布局大概如下图所示:


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

方法调用

我们先来看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的虚方法表如下所示:


对Child类型来说,action方法指向Base中的代码,toString方法指向Object中的代码,而step()指向本类中的代码。

这个表在类加载的时候生成,当通过对象动态绑定方法的时候,只需要查找这个表就可以了,而不需要挨个查找每个父类。

接下来,我们看对变量的访问。

变量访问

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

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

小结

本节,我们通过一个例子,介绍了类的加载、对象创建、方法调用以及变量访问的内部过程。现在,我们应该对继承的实现有了一个比较清楚的理解。

之前我们提到过,继承其实是把双刃剑,为什么这么说呢?让我们下节来探讨。

----------------

未完待续,查看最新文章,敬请关注微信公众号“老马说编程”(扫描下方二维码),从入门到高级,深入浅出,老马和你一起探索Java编程及计算机技术的本质。原创文章,保留所有版权。

-----------

更多相关原创文章

计算机程序的思维逻辑 (13) - 类

计算机程序的思维逻辑 (14) - 类的组合

计算机程序的思维逻辑 (15) - 初识继承和多态

计算机程序的思维逻辑 (16) - 继承的细节

计算机程序的思维逻辑 (18) - 为什么说继承是把双刃剑

计算机程序的思维逻辑 (19) - 接口的本质

计算机程序的思维逻辑 (20) - 为什么要有抽象类?

计算机程序的思维逻辑 (21) - 内部类的本质

以上是关于计算机程序的思维逻辑 (17) - 继承实现的基本原理的主要内容,如果未能解决你的问题,请参考以下文章

计算机程序的思维逻辑 (16) - 继承的细节

计算机程序的思维逻辑 (16) - 继承的细节

计算机程序的思维逻辑 (14) - 类的组合

计算机程序的思维逻辑 (18) - 为什么说继承是把双刃剑

计算机程序的思维逻辑 (18) - 为什么说继承是把双刃剑

计算机程序的思维逻辑 (14) - 类的组合