多態的詳細介紹

多態：
   定義：某一類事物的多種存在形態
列：動物中 貓 狗；
    貓這這個對象對應的類型是貓類型；
          貓 a = new 貓()；
    同時貓也是動物中的一種，也可以把貓稱爲動物；
        動物 b = new 貓();
    動物是貓和狗具體事物中抽取出來的父類型
       父類型引用指向子類型對象。

對象的多態性：
    class 動物{
    class 貓 extends 動物{}
    class 狗 extends 動物{}
        貓 a = new 貓();
        動物  b = new 貓();//一個對象兩種形態
    貓這類事物即具備貓的形態又具備動物的形態，也就算對象的多態性；
    簡單的說：就是一個對象對應着不同的類型；
    
多態在代碼中的體現：
    父類或者接口的引用指向其子類對象
    
多態的好處：
    提高了代碼的擴展性，前期定義的代碼可以使用後期定義的內容；


    abstract class Animal{
        abstract void eat();

}

    class Dog extends Animal{

        void eat(){
    System.out.println("啃骨頭")；
    }
        void lookHome(){
    System.out.println("看家")；
    }

}
    
    class Cat extends Animal{
            void eat(){
    System.out.println("吃魚")；
    }
    void catchMouse(){
    System.out.println("抓老鼠")；
    }

}
    class DuoTaiDemo{

    public static void main(String[] args){
            
        Cat c = new Cat();
        Dog d = new Dog();
        Animal a = new Dog();
                method1(a);
        method1(c);
        method1(d);

    }

    public static viod method1(Animal a){
        a.eat();
        a.catchMouse();//編譯報錯，動物裏沒有抓老鼠的方法。
        
    }

}
《多態的弊端：
        前期定義的內容不能調用後期子類中特有的內容。
  多態的前提：
        1：必須有關係 ：繼承 實現 。
        2：要有覆蓋。
》

    if(a instanceof Cat){
    Cat c = (Cat)a;
    c.catchMouse();
/*
java 中的instanceof 運算符是用來在運行時指出對象是否是特定類的一個實例。instanceof通過返回一

個布爾值來指出，這個對象是否是這個特定類或者是它的子類的一個實例。
用於判斷對象的具體類型，只能用於引用數據類型判斷，通常在向下轉型前用於健壯性判斷；
*/    

}

    Animal a = new Cat();//自動類型提升貓對象，提升了動物類型，但是特有的功能無法訪問
                 //作用就是限制了對特有功能的訪問；
                 //專業上講：向上轉型將子類型隱藏，就不使用子類的特有方法；
                 //如果還想使用具體動物貓的特有功能，可以將該對象進行向下轉型；
                 //向下轉型的目的是爲了使用子類中的特有方法。
    a.eat();
    Cat c = (Cat)a;
    c.eat();
    c.catchMouse();


/*注意：對於轉型，自始至終都是子類對象在做着類型的變化(如小貓轉動物，小貓轉小貓)

Animal an = new Dog();
Cat c = (Cat)an;
錯誤：報classCatException 類型轉換異常

*/


class 畢姥爺{
         viod 講課(){
    System.out.println("管理課")；

    }
              viod 釣魚(){
    System.out.println("釣魚")；

    }
}

class 畢老師 extends 畢姥爺{
         viod 講課(){
    System.out.println("java")；

    }
              viod 看電影(){
    System.out.println("無間道")；

    }
}

class DuoTaiDemo{

public static void main(String[] args){
    //畢老師 b = new 畢老師();
    //   b.講課();
    //   b.看電影();

    畢姥爺 bl = new 畢老師();
         bl.講課();   -----------System.out.println("java")；
         bl.釣魚();   -----------System.out.println("釣魚")；
    //   bl.看電影();  錯誤

    }
}


多態時 成員的特點：

1，成團變量：
    
    編譯時參考引用型變量所屬的類中是否有調用的變量，有，編譯通過；沒有，編譯失敗；
    運行時參考引用型變量所屬的類中是否有調用的變量，並運行該屬性類中的成員變量；
    簡單說：編譯和運行都參考等號的左邊。
2，成員函數：
    
    編譯時參考引用型變量所屬的類中是否有調用的函數，有，編譯通過；沒有，編譯失敗；
    運行時參考的是對象所屬的類中是否有調用的函數；
    簡單說：編譯看左邊，運行看右邊。
3，靜態函數：
    
    編譯時參考引用型變量所屬的類中是否有調用的靜態方法；
    運行時參考引用型變量所屬的類中是否有調用的靜態方法；
    簡單說：編譯和運行都看左邊。
        <!--靜態方法是不需要對象的，直接類名調用即可-->

---------------------------------------
成員變量：
class Fu{

    int num = 3;
}
class Zi extends Fu{

    int num = 4;
}
class DuoTaiDemo{

public static void main(String[] args){    
    
    Fu f = new Zi();
    System.out.println(f.num)；//運行結果等於3  編譯和運行都看左邊
    }
}
------------------------------------------
成員函數：
class Fu{
    
    void Show(){
   System.out.println("fu show")；
    
    }
}

class Zi extends Fu{
    
    void Show(){
   System.out.println("zi show")；
    
    }
}

public static void main(String[] args){    
    
    Fu f = new Zi();
    f.show()；//運行結果等於"zi show"  編譯看左邊和運行看右邊
    }
}