多態概念

Java多態的實現條件：繼承、重寫、向上轉型。

繼承：子類用extends關鍵字繼承父類，例如：public student extends person{}，students是子類，person是父類。

重寫：子類繼承父類以後，重寫父類的方法，方法名、返回值類型、參數相同，但是方法體不一樣。在調用方法時，會調用子類的方法。

向上轉型：就是子類對象賦值給父類對象的引用，這樣就可以引用父類的方法和子類的方法。

　　其實除了繼承型多態、還有接口型多態，繼承是單繼承，而接口就不一樣了，接口可以有多個實現。

　　子類Child繼承父類Father，我們可以編寫一個指向子類的父類類型引用，該引用既可以處理父類Father對象，也可以處理子類Child對象，當相同的消息發送給子類或者父類對象時，該對象就會根據自己所屬的引用而執行不同的行為，這就是多態。即多態性就是相同的消息使得不同的類做出不同的響應。

　　其實並沒有多難，只要我們好好的理解了。接下來就來一個多態的簡單例子。

父類：
public class Person {  
  public void getName(){
    System.out.println("name null");
  }
  
  public void getAge(){
    System.out.println("age null");
  }

　public void getAAA(){
  　System.out.println("AAA AAA");
　}
}
子類：public class Student extends Person {
  
  @Override
  
 
public void getAge() {
    System.out.println("23 years old!");
  }
  
  @Override
  public void getName() {
    System.out.println("my name is Libh!");  }
   public void getStudentsClass(){
      System.out.println("12class!");
    }
}
main方法：
public class polymorphic_test {
  
  public static void
 
 main(String[] args) {
  
    Person students = new Student();
    students.getName();
    students.getAge();
    students.getAAA();
    ((Student) students).getStudentsClass();
  }
  
}
結果：
my name is Libh!
23 years old!
AAA AAA
12class!

　　子類對象指向了父類對象的引用，當我們調用方法時，如果有方法重寫的情況，我們調用的是子類重寫之後的方法。如果調用子類獨有的方法就必須將引用變量強制轉換成Students，如果父類方法沒有發生重寫，就還是調用的父類的方法。

　　下面是我遇見多態的一個經典例子：（摘抄至：https://blog.csdn.net/thinkGhoster/article/details/2307001）

class A {
public String show(D obj)...{
return ("A and D");
}
public String show(A obj)...{
return ("A and A");
}
}
class B extends A...{
public String show(B obj)...{
return ("B and B");
}
public String show(A obj)...{
return ("B and A");
}
}
class C extends B...{}
class D extends B...{}

運行：

A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println(a1.show(b)); ①
System.out.println(a1.show(c)); ②
System.out.println(a1.show(d)); ③
System.out.println(a2.show(b)); ④
System.out.println(a2.show(c)); ⑤
System.out.println(a2.show(d)); ⑥
System.out.println(b.show(b)); ⑦
System.out.println(b.show(c)); ⑧
System.out.println(b.show(d)); ⑨

答案

① A and A
② A and A
③ A and D
④ B and A
⑤ B and A
⑥ A and D
⑦ B and B
⑧ B and B
⑨ A and D

①②③比較好理解，一般不會出錯。④⑤就有點糊塗了，為什麽輸出的不是"B and B”呢？！！先來回顧一下多態性。

運行時多態性是面向對象程序設計代碼重用的一個最強大機制，動態性的概念也可以被說成“一個接口，多個方法”。Java實現運行時多態性的基礎是動態方法調度，它是一種在運行時而不是在編譯期調用重載方法的機制。

方法的重寫Overriding和重載Overloading是Java多態性的不同表現。重寫Overriding是父類與子類之間多態性的一種表現，重載Overloading是一個類中多態性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫(Overriding)。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被“屏蔽”了。如果在一個類中定義了多個同名的方法，它們或有不同的參數個數或有不同的參數類型，則稱為方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型。

當超類對象引用變量引用子類對象時，被引用對象的類型而不是引用變量的類型決定了調用誰的成員方法，但是這個被調用的方法必須是在超類中定義過的，也就是說被子類覆蓋的方法。 （但是如果強制把超類轉換成子類的話，就可以調用子類中新添加而超類沒有的方法了。）

好了，先溫習到這裏，言歸正傳！實際上這裏涉及方法調用的優先問題 ，優先級由高到低依次為：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。讓我們來看看它是怎麽工作的。

比如④，a2.show(b)，a2是一個引用變量，類型為A，則this為a2，b是B的一個實例，於是它到類A裏面找show(B obj)方法，沒有找到，於是到A的super(超類)找，而A沒有超類，因此轉到第三優先級this.show((super)O)，this仍然是a2，這裏O為B，(super)O即(super)B即A，因此它到類A裏面找show(A obj)的方法，類A有這個方法，但是由於a2引用的是類B的一個對象，B覆蓋了A的show(A obj)方法，因此最終鎖定到類B的show(A obj)，輸出為"B and A”。

再比如⑧，b.show(c)，b是一個引用變量，類型為B，則this為b，c是C的一個實例，於是它到類B找show(C obj)方法，沒有找到，轉而到B的超類A裏面找，A裏面也沒有，因此也轉到第三優先級this.show((super)O)，this為b，O為C，(super)O即(super)C即B，因此它到B裏面找show(B obj)方法，找到了，由於b引用的是類B的一個對象，因此直接鎖定到類B的show(B obj)，輸出為"B and B”。

按照上面的方法，可以正確得到其他的結果。

問題還要繼續，現在我們再來看上面的分析過程是怎麽體現出藍色字體那句話的內涵的。它說：當超類對象引用變量引用子類對象時，被引用對象的類型而不是引用變量的類型決定了調用誰的成員方法，但是這個被調用的方法必須是在超類中定義過的，也就是說被子類覆蓋的方法。還是拿a2.show(b)來說吧。

a2是一個引用變量，類型為A，它引用的是B的一個對象，因此這句話的意思是由B來決定調用的是哪個方法。因此應該調用B的show(B obj)從而輸出"B and B”才對。但是為什麽跟前面的分析得到的結果不相符呢？！問題在於我們不要忽略了藍色字體的後半部分，那裏特別指明：這個被調用的方法必須是在超類中定義過的，也就是被子類覆蓋的方法。B裏面的show(B obj)在超類A中有定義嗎？沒有！那就更談不上被覆蓋了。實際上這句話隱藏了一條信息：它仍然是按照方法調用的優先級來確定的。它在類A中找到了show(A obj)，如果子類B沒有覆蓋show(A obj)方法，那麽它就調用A的show(A obj)（由於B繼承A，雖然沒有覆蓋這個方法，但從超類A那裏繼承了這個方法，從某種意義上說，還是由B確定調用的方法，只是方法是在A中實現而已）；現在子類B覆蓋了show(A obj)，因此它最終鎖定到B的show(A obj)。這就是那句話的意義所在。

多態學習筆記