多态

多态

向上转型

通过继承的关系基类的引用视为其父类的引用。

class Instrument {
    public void play(String note){
        System.out.println("Instrument.play ");
    }
}

class Wind extends Instrument {
    public void play(String note){
        System.out.println("Wind.play "+note);
    }
}

class Music {
    public static void tune(Instrument i){
        i.play("middle_c");
    }

    public static void main(String[] args) {
        Wind flute = new Wind();
        tune(flute);//Wind.play middle_c
    }
}

运行时Music.tune(Instrument i)能自动判断传入Instrument的类型，实际传入类型是Wind，从而调用wind的play方法；

方法调用绑定

Java中除了static方法和final方法（private方法属于final方法）之外，其他所有方法都是后期绑定。

如上例子，main方法是在执行tune方法之后才确定绑定为Wind的，这被称作后期绑定；若在执行之前进行绑定呢？

class Instrument {
    public static void play(String note){
        System.out.println("Instrument.play");
    }
}

class Wind extends Instrument {
    public static void play(String note){
        System.out.println("Wind.play"+note);
    }
}

class Music {
    public static void tune(Instrument i){
        i.play("middle_c");
    }

    public static void main(String[] args) {
        Wind flute = new Wind();
        tune(flute);//Instrument.play
    }
}

此时Instrument的play方法修饰为static,而输出结果却没有动态绑定到Wind的play方法，输出结果为Instrument.play，所以当方法修饰为static,final或者是private就是告诉编译器不需要对此方法进行动态的绑定。

构造器的调用顺序

构造器调用的顺序是先调用当前类父类，如果其父类仍然有父类，就不断反复递归下去，这样才能确保可使用的成员都能够得到构建。

class LivingCreature {
    public LivingCreature(){
        System.out.println("LivingCreature");
    }
    protected void disp(){
        System.out.println("LivingCreature disp");
    }
}

class Animal extends LivingCreature {
    public Animal()
    {
        System.out.println("Animal");
    }
    protected void disp(){
        System.out.println("Animal disp");
    }
}

class Amphibian extends Animal {
    public Amphibian(){
        System.out.println("Amphibian");
        super.disp();
    }
    public void disp(){
        System.out.println("Amphibian disp");
        super.disp();
    }

    public static void main(String[] args) {
        Amphibian amp = new Amphibian();
        amp.disp();
    }
}

结果：
LivingCreature
Animal
Amphibian
Amphibian disp
Animal disp

当前导出类的基类全都按继承关系顺序初始化完成，Amphibian对象的全体成员也得到构建。super方法是调用当前类的父类的方法。

构造器内部调用未绑定的动态方法

如果在一个构造器内部调用一个未被绑定的方法会发生什么呢，动态方法是在运行时才被确定绑定的，但是在创建一个对象时构造器会被执行，其内部的动态方法无法知道它是属于哪个类，然而动态绑定的方法调用会向导出类方向向外深入，调用导出类的方法。

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;

    void draw() {
        System.out.println("RoundGlyph draw, radius = "+radius);
    }
    RoundGlyph(int r){
        radius = r;
        System.out.println("RoundGlyph.RoundGlyph, radius = "+radius);
    }

    public static void main(String[] args) {
        new RoundGlyph(5);
    }

}

结果：
Glyph before draw()
RoundGlyph draw, radius = 0
Glyph after draw()
RoundGlyph.RoundGlyph, radius = 5

在创建RoundGlyph时，先执行其基类Glyph的构造方法，但是基类中有一个draw()动态未绑定的方法，它的调用会根据继承关系向外层次调用子类里的方法，（子类的draw方法覆盖了父类的）但是为什么radius = 0呢？因为radius成员还未进行初始化。

补充初始化调用顺序

1. 先将初始化对象分配的存储空间初始化成二进制的零。
2. 向上层次递归调用父类构造器（在此期间构造器中使用的外部成员都是初始化状态）
3. 调用成员的初始化方法。
4. 调用子类构造器。