一、什么是多態？

多態的詞組字面意思是： 某種事物多種形態。
但是對于我們學習Java 的程序原來說，就不不能簡單這樣來理解了。
多態是 完成某個行為，不同的對象去實現會有不同的效果。現在還看不懂其實沒關系，也就簡單提一嘴。

舉個栗子：

有一天，學校二食堂做了一大盤深海大閘蟹，你和小帥同時在排隊。此時一位長得very beautiful 的女生——小美來了，到窗口看了一下菜，感覺不錯，也想吃。但是排隊的人太多了，就想插下隊。你一看，我丟想插隊，門都沒有，表現出不肯的樣子。而你后面的小帥眼睛一亮，就說，小美同學你好，我看你插隊的話影響不好，不如我多打一份給你，倒時候加個微信發我就行了。此時這就是多態，不同的人對一件事表現出不同的狀態。到頭來‘你’還在為什么，自己還單身著。小帥到后面，小美微信也加了，說：就一頓飯錢也沒多少，算了算了。此時小美就非常感動，說：小帥同學下次我會請你吃一頓。這樣一來而去。。。

磨刀不誤砍柴功，要想學真正學會多態，就要理解一下，向上轉型是怎么轉的？靜態綁定是怎么綁定的，方法的覆蓋是？最后，學完才可以說學會了Java 的多態，太哇塞了！！！

二、轉型

向上轉型

向上轉型： 父類 引用 子類型對象
也好理解 兒子孝順父親，給父親買點禮物，父親樂意地接受了。

例子：創建一個父類 Animal 其子類有Dog， Cat
測試類 Test

public class Animal {public String name;//無參構造方法public Animal() {}//有參構造方法public Animal(String name) {this.name = name;}//動物會說方法public void speak() {System.out.println("會說話-----------");}}

public class Cat extends Animal{//無參構造方法public Cat() {}//有參構造方法public Cat(String name) {super(name);//子類繼承父類，就要先對父類進行初始化}public void speak() {System.out.println(this.name+"會喵喵叫-----");}}

public class Dog extends Animal{//無參構造方法public Dog() {}//有參構造方法public Dog(String name) {super(name); //子類繼承父類，就要先對父類進行初始化}public void speak() {System.out.println(this.name+"會汪汪叫------");}//dog 特有的方法public void lookHouse() {System.out.println(this.name+"會看家-----------");}}

public class Test {public static void main(String[] args) {Animal dog = new Dog("小黑");dog.speak();Animal cat = new Cat("小咪");cat.speak();}
}

有三種表示方式
1.直接賦值

2.方法傳參

3.返回值

總結
優點 父類可以接受任何的子類

又創建了一個Cat 類 ，也是可以接受的。

缺點 不能調用子類特有方法，因為你還是Animal 類！

向下轉型

父類強轉子類

Animal 轉為 Dog子類
a instanceof b ： 判斷 a 是否為b類型 。是返回 true ,否返回false

public class Test {public static void main(String[] args) {Animal animal = new Dog("小黑");if(animal instanceof Dog) { Dog dog = (Dog)animal;//可以 調用子類特有的方法dog.lookHouse();}}
}

注意了 強轉是要注意 子類一致
一開始是狗，怎么強轉成貓呢？
就像養一只小狗，再怎么養，也不會變成小貓。因為一生下來就決定了的。

public class Test {public static void main(String[] args) {Animal animal = new Dog("小黑");Cat cat = (Cat) animal; //errorcat.speak(); //error}
}

總結：

三、方法覆蓋與方法重載

方法重載： 我想大家都應該知道：就是在同一個類中，方法名相同，參數列表不同。就只要記住一個方法名，就可以調用不同的參數列表，提高了效率。

以add() 加法為例子：

public class Test {public static void main(String[] args) {System.out.println("方法重載");//相同 add方法名，不同參數列表。構成方法重載System.out.println(add(1,5));System.out.println(add(1,2,3));}public static int add(int a,int b) {return a+b;}public static int add(int a,int b,int c) {return a+b+c;}
}

方法覆蓋: 也叫方法重寫。發生在父子類之間的關系，方法名相同，參數列表相同，返回值也要相同。
也好理解，重寫是重新再寫一遍唄，不改變原來的。
父類的方法完成不了子類的需求，就要重寫。

方法覆蓋也存在一些細節：
1.static ，final ，private 修飾的方法，構造方法 不能被重寫。
2.子類重寫的方法，訪問權限要 >= 父類 原來的方法。
3.重寫方法的返回值類型也可不同，但是要構成父子類關系。

四、綁定

動態綁定

動態綁定是理解多態的基礎。
那什么是動態綁定呢？
程序在編譯的時候，確實是調用了父類的方法。但在運行的時候，通過父類的引用，調用的卻是子類重寫父類的那個方法。這就叫動態綁定。

還是以之前的Animal ，Dog 為例子：
不是輸出： 會說話-------

靜態綁定

“靜態綁定"也稱為"早期綁定”。
簡單 就相當于平時調用方法 。就是調用這個方法時，編譯器確定調用這個方法。

public class Test {public static void main(String[] args) {Test test = new Test();test.func(); //確定調用func()}public  void func() {System.out.println("我就是一個普通的方法------");}
}

五、理解多態

現在，我們學習了
向上轉型 就是父類型 引用 子類型對象 ，方法的重寫是 父類的方法完成不了子類的需求，就要重寫。 靜態綁定：運行是調用子類重寫父類的方法。

請看

public class Test {public static void main(String[] args) {Animal dog = new Dog("小黑");Animal cat = new Cat("小花");autoSpeak(dog);autoSpeak(cat);}public static void autoSpeak(Animal animal) {animal.speak();}
}

autoSpeak() 方法就會自動的調用 子類的speak（）方法。
不要判斷 是否為 Dog 類 還是 Cat 類。
1.能夠降低代碼的 “圈復雜度”, 避免使用大量的 if - else
2.可擴展能力強。