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

Question

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方法）。
常见的多态代码是向上转型，把一个子类的实例赋值给父类的引用，这时候产生多态，这个我知道。但是②这个多态是怎么产生的呢？
主要就是①②这两个问题

Answer 1

如果题主看过《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> 方法早得多。

Answer 2

一般的函数覆盖的实现可以想象成类里面有一个指向函数的指针(或者引用函数的引用)。在派生类中，覆盖了相同签名的函数，就跟指针/引用所指向/引用的函数是另一个函数差不多。

Answer 3

1. 为什么Glyph的构造器会去调用子类的draw方法而不去调用自己的draw方法呢？...
   RoundGlyph rg = new RoundGlyph(5); 这段代码在构造函数里传了一个整型参数

2. 多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）。
   我认为你可以理解为不同类（父类、子类）里的构造函数会有不同的（构造）效果。

Answer 4

你可以理解成光调用方法其实本质上隐含了一个语义就是this.方法()
你说的第二个问题没有看明白

Answer 5

你没理解java的方法解析.
你可以在父类的构造器第一行添加下面这行代码

System.out.println(this.getClass().getName());

然后看看输出结果， 你应该就明白了。