Thinking In Java 4th Chap8 多态（未完）

多态的意义：改善代码的可读性并且使得程序“可扩展”

多态方法调用允许一种类型表现出与其他相似类型之间的"区别"，基于方法的行为不同而表现出来

将一个方法调用同一个方法主体关联起来称作绑定，程序执行前绑定称为前期绑定，运行时根据对象的类型进行绑定称为后期绑定。

　　Java中除了static和final（包括private）方法，都采用后期绑定。

向上转型可以表现为此语句：(在调用方法时总是会进行正确的调用，也即调用正确的子类的方法）

　　（Shape类是Circle类的基类）Shape s = new Circle();

　　　调用方法:s.draw();(draw()方法已经在Circle类中被覆写）实际上调用的还是Circle.draw()，虽然对象s被声明为Shape（但是指向Circle类的引用）

package Music;
enum Note{
    MIDDLE_C,C_SHARP,B_FLAT
}
class Instrument{
    void play(Note n) {
        System.out.print("Instrument.play()" + n);
    }
};
class Percussion extends Instrument{
    void play(Note n) {
        System.out.print("Percussion.play()" + n);
    }
};
class Stringed extends Instrument{
    void play(Note n) {
        System.out.print("Stringed.play()" + n);
    }
};
class Wind extends Instrument{
    void play(Note n) {
        System.out.print("Wind.play()" + n);
    }
};
class Music4{
    static void tune(Instrument i){
        i.play(Note.MIDDLE_C);
    }
    static void tuneAll(Instrument[] e){
        for(Instrument i:e){
            tune(i);
        }
    }
    public static void main(String[]args){
        Instrument[]orchestra={
                new Wind(),
                new Percussion(),
                new Stringed(),
        };
        tuneAll(orchestra);
    }
};

上述“向上引用”的缺陷是：如果覆写了private方法，那么“向上引用”的结果是调用基类的private方法

 只有普通的方法的调用可以是多态的，如果直接访问某个域，那么访问就在编译期解析：

class Super{
    public int field=0;
    public int getField(){
        return field;
    }
}
class Sub extends Super{
    public int field=1;
    public int getField(){
        return field;
    }
    public int getSuperField(){
        return super.field;
    }
}
class FieldAccess{
    public static void main(String []args){
        Super sup=new Sub();//upcasting
        System.out.println("sup.field="+sup.field+",sup.getfield()="+sup.getField());
        Sub sub=new Sub();
        System.out.println("sub.field="+sub.field+",sub.getfield()="+sub.getField()+",sub.getSuperField()="+sub.getSuperField());

    }
}/**output:
 sup.field=0,sup.getfield()=1
 sub.field=1,sub.getfield()=1,sub.getSuperField()=0*/

如果某个方法是静态的，则不具备多态性：

class StaticSuper{
    public static String staticGet(){
        return "Base staticGet()";
    }
    public String dynamicGet(){
        return "Base dynamicGet()";
    }
}
class StaticSub extends StaticSuper{
    public static String staticGet(){
        return "Sub staticGet()";
    }
    public String dynamicGet(){
        return "Sub dynamicGet()";
    }
}
class StaticPolymorphism{
    public static void main(String[]args){
        StaticSuper sup=new StaticSub();
        System.out.println("sup.staticGet()="+sup.staticGet());
        System.out.println("sup.dynamicGet()="+sup.dynamicGet());
    }
}
/**output:
 * sup.staticGet()=Base staticGet()
 * sup.dynamicGet()=Sub dynamicGet()*/

构造器和多态（构造器隐式的声明为static）

构造器的调用顺序实例：

class Meal{
    Meal(){
        System.out.print("Meal()");
    }
}
class Bread{
    Bread(){
        System.out.print("Bread()");
    }
}
class Cheese{
    Cheese(){
        System.out.print("Cheese()");
    }
}
class Lettuce{
    Lettuce(){
        System.out.print("Lettuce()");
    }
}
class Lunch extends Meal{
    Lunch(){
        System.out.print("Lunch()");
    }
}
class PortableLunch extends Lunch{
    PortableLunch(){
        System.out.print("PortableLunch()");
    }
}
class Sandwich extends PortableLunch{
    private Bread b = new Bread();
    private Cheese c= new Cheese();
    private Lettuce l = new Lettuce();
    Sandwich(){
        System.out.print("Sandwich()");
    }
    public static void main(String[]args){
       new Sandwich();
    }
}
/**output:
 * Meal()Lunch()PortableLunch()Bread()Cheese()Lettuce()Sandwich()*/

可见构造器的调用顺序：基类构造器->组合方法调用成员构造器->继承类构造器（自己）

继承和清理：