Java，在构造器里调用多态方法

问题描述

问 题

class Glyph {
    void draw() { System.out.println("Glyph.draw()"); }
    Glyph() {
        System.out.println("Glyph() before draw()");
        draw();
        System.out.println("Glyph() after draw()");
    }
}
class RoundGlyph extends Glyph {
    private int radius = 1;
    RoundGlyph(int r) {
        radius = r;
        System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);
    }
    void draw() {
        System.out.println("RoundGlyph.draw(), radius = " + radius);
    }
    
    void superDraw(){
        super.draw();
    }

}
public class PolyConstructors {
    public static void main(String[] args) {
        RoundGlyph rg = new RoundGlyph(5);
        rg.superDraw();
    }
}

这样一段代码，执行结果是这样的：
Glyph() before draw()
RoundGlyph.draw(), radius = 0
Glyph() after draw()
RoundGlyph.RoundGlyph(), radius = 5
Glyph.draw()

Thinking In Java中有一句话

Glyph.draw()方法设计将要被覆盖，这种覆盖是在RoundGlyph中发生的。（这里都OK）但是Glyph构造器会调用这个方法，结果导致了对RoundGlyph.draw()的调用。

这句话我就不太明白了，①为什么Glyph的构造器会去调用子类的draw方法而不去调用自己的draw方法呢？重写明明是在子类中发生的呀，父类中的draw方法并没有被重写吧（看我后来又调了super.draw，结果也是父类中的draw方法）。
常见的多态代码是向上转型，把一个子类的实例赋值给父类的引用，这时候产生多态，这个我知道。但是②这个多态是怎么产生的呢？
主要就是①②这两个问题

解决方案

如果题主看过《java 虚拟机规范》这个问题就很简单了。

首先，要明白类的实例化过程。当执行 new 指令时，一个以此为类型的对象将会分配到 GC 堆中，并且所有的实例变量都会进行初始化为响应类型的初始值。此时实例完成了默认初始化，之后虚拟机调用类的 <init> 方法进行《Thinking in Java》所说的指定初始化、构造初始化的过程，另外 <init> 方法的调用是递归的一直到 Object 的 <init> 方法为止。

所以 RoundGlyph 的实例化过程是这样的：

 1. Object 的默认初始化
 2. Glyph 的默认初始化
 3. RoundGlyph 的默认初始化
 4. Glyph 构造器中的内容，也就是 System.out.println("Glyph() before draw()"); draw(); 这些
 5. RoundGlyph 中剩下的初始化代码

很明显就可以看到，当构造过程到第四步时 Glyph、RoundGlyph 都只进行了默认初始化，因此此时执行 draw 方法时 radius 的值只可能是 0，不会是 1或者 5。到这里已经解释为什么 radius == 0，但还没有解释，为什么调用的是子类的 draw 方法而不是父类的。

这时，需要明白重写在字节码中是如何实现的。对于 java 的非构造、非私有、非静态、非接口等方法，在字节码中是通过 invokevirtual 指令调用的，invokevirtual 调用方法需要一个实例引用作为参数，这个实例引用是那个类型，invokevirtual 的方法。比如说：

Son 继承自 Father，他们都有 public void eat() 方法：

Father people = new Son();
people.eat();

此时 people 运行的是 Son 的 eat 方法，其实 Java 的运行时绑定实际上是通过 invokevirtual 指令来实现的，而传入的实例引用实际上决定了 invokevirtual 调用的哪一个方法。

对于题主的例子，draw 方法既不是构造方法也不是私有方法也不是静态方法，在编译过程中会被指定为 invokevirtual 指令调用，所以调用 Glyph 的 draw 还是 RoundGlyph 的 draw 方法实际上是由传入的实例引用决定的。

由于这是由 new RoundGlyph() 引发的指令，所以传递的是 RoundGlyph 的实例引用。因此在 RoundGlyph 的实例化过程的第四步的 draw() 应该调用 RoundGlyph 的 draw() 方法。上面说过，到第四步时只进行了默认初始化因此 radius 的值为 0. 输出的是： RoundGlyph.draw(), radius = 0

第四步执行完了之后到第五步，RoundGlyph 实例会进行指定初始化，radius 的值变为1，再进行构造初始化，radius 的值变为 5。

之后执行 rg.superDraw()，rg 是 RoundGlyph 的实例引用，但是由于使用了 super.draw()，在编译过程中调用私有方法、父类方法会使用 invokespecial 指令，invokespecial 是在编译期指定好的，因此即使传入的是 RoundGlyph 引用，它依旧调用的是 Glyph 的 draw 方法。所以可以这样理解，invokespecial 指令实现了静态绑定的语义，invokevitual 指令实现了动态绑定的语义。

写了这么多，检验一下题主理解了没，把 Glyph 的 draw 改成 private 修饰，会输出什么？

--------------------------------------- 补充评论中的问题 -------------------------------------------

语句 RoundGlyph rg = new RoundGlyph(5); 的字节码是这样的：

NEW com/kyle/RoundGlyph
DUP
ICONST_5
INVOKESPECIAL com/kyle/RoundGlyph.<init> (I)V

其中 new 指令创建出了 RoundGlyph 的实例应用，然后和常数 5 一起进入 <init> 的栈帧。其实我在答案开头就说过，规范规定当执行 new 指令时，一个以此为类型的对象将会分配到 GC 堆中，并且所有的实例变量都会进行初始化为响应类型的初始值。所以，RoundGlyph 的实例应用是在 new 指令中创建，比 <init> 方法早得多。

这篇关于Java，在构造器里调用多态方法的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！