JAVA编程思想笔记--多态

1. 这种把对某个对象的引用视为对其基类型的引用的做法被称作向上转型—-因为在继承数的画法中，基类是放置在上方的。

public class Test {

    public enum Note{
        MIDDLE_C , C_SHARP , B_FLAT ;
    }

    class Instrument{
        public void play(Note n){
            System.out.print("Instrument.play()");
        }
    }

    class Wind extends Instrument{
        public void play(Note n){
            System.out.print("Wind.play()"+n);
        }
    }
}

class Music {
    public static void tune(Instrument i){
        i.play(Test.Note.MIDDLE_C)
    }

    public static void main(String[] args){
        Wind flute = new Wind();//后期绑定(动态绑定或运行时绑定)
        tune(flute);
    }
}
//output   :  Wind.play() MIDDLE_C

2.向上转型，Circle类继承Shape类

Shape s = new Circle();

假如你调用一个基类方法(它已在导出类中被覆盖):

s.draw();

由于后期绑定(多态)，还是正确调用了Circle.draw()方法。

3.缺陷：”覆盖”私有方法

public class MainJava { 

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

     public static void main(String[] args) { 
         MainJava po = new Derived();
         po.f();
    }

}

public class Derived extends MainJava{
    //就是一个全新的方法
    public void f(){
        System.out.println("public f()");
    }
}
//output : private f();
//由于private方法被自动认为是final方法，而且对导出类是屏蔽的。
//在这种情况下，Derivied类中的f()方法就是一个全新的方法。
//既然基类中的f()方法在子类Derived中不可见，因此甚至不能被重载。

确切地说，在导出类中，对于基类中的private方法，最好采用不同的名字。

4.缺陷：只有普通的方法调用可以是多态的。

5.构造器和多态
(1)基类的构造器总是在导出类的构造过程中被调用，而且按照继承层次逐渐向上链接，以使每个基类的构造器都能得到调用。

class Meal{
         Meal(){
             System.out.println("Meal()");
         }
     }


class Bread{
         Bread(){
             System.out.println("Bread()");
         }
     }

class Cheese{
         Cheese(){
             System.out.println("Cheese()");
         }
     }

class Lettuce{
         Lettuce(){
             System.out.println("Lettuce()");
         }
     }

class Lunch extends Meal{
         Lunch(){
             System.out.println("Lunch()");
         }
     }

class PortableLunch extends Lunch{
         PortableLunch(){
             System.out.println("PortableLunch()");
         }
     }

//编译遇到extend则先执行基类
public class MainJava extends PortableLunch{ 
     //如果MainJava不继承PortableLunch,则先执行 变量和对象的初始化
     private  Bread b = new Bread();
     private Cheese c = new Cheese();
     private Lettuce l = new Lettuce();
     public MainJava(){
         System.out.println("MainJava");
     }

     public static void main(String[] args) { 
        //System.out.println("fuck");
        new MainJava();
     } 
}

//输出 
//Meal()
//Lunch()
//PortableLunck()
//Bread()
//Cheese()
//Lettuce()
//Sandwich()

(2)向上转型是安全的，因为基类不会具有大于导出类的接口，因此，我们通过基类接口发送的消息保证都能被接受。