【Java】多态和动态绑定中的坑

大一学C++的时候就感觉多态这部分略烦，小坑不断。一年过后学习Java再次遇到多态的问题，写一篇笔记来记下发现的各种小坑，以供以后复习。

来看下面一段代码：

enum Note {
    MIDDLE_C,
    C_SHARP,
    B_FLAT
}

class Instrument {
    public int field = 0;

    void play(Note note) {
        System.out.println("Instrument.play() " + note);
    }

    String what() {
        return "Instrument";
    }

    void adjust() {
        System.out.println("Adjust Instrument");
    }
}

class Wind extends Instrument {
    public int field = 1;

    @Override
    void play(Note note) {
        System.out.println("Wind.play() " + note);
    }

    @Override
    String what() {
        return "Wind";
    }

    @Override
    void adjust() {
        System.out.println("Adjust Wind");
    }
}

class Brass extends Wind {
    @Override
    void play(Note note) {
        System.out.println("Brass.play() " + note);
    }

    @Override
    void adjust() {
        System.out.println("Adjust Brass");
    }
}

public class Music3 {

    public static void tune(Instrument instrument) {
        instrument.play(Note.C_SHARP);
    }

    public static void tuneAll(Instrument[] instruments) {
        for (Instrument instrument : instruments) {
            tune(instrument);
        }
    }

    public static void main(String... args) {
        Instrument[] orchestra = {
                new Wind(),
                 new Brass()
        };
        tuneAll(orchestra);
    }

}

/*
Output:
Wind.play() C_SHARP
0
Brass.play() C_SHARP
0
*/

当创建orchestra数组时，如果new的是导出类，那么他会自动向上转型成Instrument。因为Wind和Brass毕竟是继承自Instrument的，所以Instrument的接口必定存在于它导出的类中。

在Main函数中，tune方法接收一个Instrument引用，但同时也接受任何导出自Instrument的类。那么在这种情况下编译器怎样才能知道这个Instrument引用指向的是Wind对象，而不是Brass呢？实际上，编译器也不知道。。那么这个问题怎么解决呢？答案是采用动态绑定技术。

动态绑定是指在运行时根据对象的类型，将一个方法调用同一个方法主体关联起来。也就是说编译器一直不知道对象的类型，但是方法调用机制能找到正确的方法体，并加以调用。因此，tune方法就可以正确调用导出类重写的相应方法。

Note： Java中除了static方法和final方法(private方法也属于final方法)之外，其他所有方法都是动态绑定的。当然，这样做有很多好处，也有一定的麻烦。

我们来看看麻烦在哪里：

class Glyph {
    void draw() {
        System.out.println("Glyph.draw()");
    }

    private void duplicate() {
        System.out.println("Glyph.duplicate()");
    }

    Glyph() {
        System.out.println("Glyph() before draw");
        draw();// 动态绑定，调用子类覆盖的draw
        duplicate();// 非动态绑定，调用Glyph的duplicate
        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);
    }

    @Override
    void draw() {
        System.out.println("RoundGlyph.draw().radius = " + radius);
    }

    public void duplicate() {
        // 这个duplicate和父类的duplicate没有任何关系
        // 不是Override
        // 因为父类的duplicate是private final的
        System.out.println("RoundGlyph.duplicate()");
    }
}

public class PolyConstructors {
    public static void main(String...args) {
        new RoundGlyph(10);
    }
}

/*
Output:
Glyph() before draw
RoundGlyph.draw().radius = 0
Glyph.duplicate()
Glyph() after draw
RoundGlyph.RoundGlyph().radius = 10
*/

首先要说明一下Java初始化对象的实际过程：

1. 在做任何事情之前，先将分配给对象的存储空间初始化成二进制的零
2. 自下向上调用基类构造器。这里在Glyph的构造器中会调用覆盖了的draw()方法，而不是Glyph的draw()。由于步骤1的缘故，我们会发现radius的值是0
3. 完所有基类的初始化后，按照声明的顺序调用当前成员的初始化方法。这里会将radius初始化为1
4. 调用导出类的构造器主体

第一次看到这样的结果时我的内心其实是拒绝的。。觉得Glyph构造器里调用的draw()方法理所当然的就应当是Glyph.draw()。然而这是一个坑，很容易被忽视掉，而且不好debug。

Note: 在构造器内唯一能够安全调用的方法是基类中的final方法，当然包括private方法。这些方法不会被导出类覆盖，因此也就不会出现掉进上面这个坑的情况了。