2021-05-11

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();
    }
}

个人简单理解：

1、类初始化由两部分代码组成：①静态变量的显式赋值代码②静态代码块

2、没有创建对象，不会执行实例初始化相关的代码

顺初始化顺序：

父类(静态域按顺序加载)–>子类(静态域按顺序加载) –>父类(非静态变量,非静态代码块,构造函数)–>子类(非静态变量,非静态代码块,构造函数)

 

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

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

 

回答：

首先，要明白类的实例化过程。当执行 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 指令实现了动态绑定的语义。