以下內容參考https://www.cnblogs.com/ChrisMurphy/p/5054256.html

父類引用指向子類物件指的是：

例如父類Animal，子類Cat,Dog。其中Animal可以是類也可以是介面，Cat和Dog是繼承或實現Animal的子類。

Animal animal = new Cat();

即宣告的是父類，實際指向的是子類的一個物件。

那這麼使用的優點是什麼，為什麼要這麼用？可以用這幾個關鍵詞來概括：多型、動態連結，向上轉型

也有人說這是面向介面程式設計，可以降低程式的耦合性，即呼叫者不必關心呼叫的是哪個物件，只需要針對介面程式設計就可以了，被呼叫者對於呼叫者是完全透明的。讓你更關注父類能做什麼,而不去關心子類是具體怎麼做的,你可以隨時替換一個子類,也就是隨時替換一個具體實現,而不用修改其他.

以後結合設計模式（如工廠模式，代理模式）和反射機制可能有更深理解。

下面介紹java的多型性和其中的動態連結，向上轉型：

面向物件的三個特徵：封裝、繼承和多型；

封裝隱藏了類的內部實現機制，可以在不影響使用者的前提下修改類的內部結構，同時保護了資料；

繼承是為了重用父類程式碼，子類繼承父類就擁有了父類的成員。

方法的重寫、過載與動態連線構成多型性。Java之所以引入多型的概念，原因之一是它在類的繼承問題上和C++不同，後者允許多繼承，這確實給其帶來的非常強大的功能，但是複雜的繼承關係也給C++開發者帶來了更大的麻煩，為了規避風險，Java只允許單繼承，派生類與基類間有IS-A的關係（即“貓”is a “動物”）。這樣做雖然保證了繼承關係的簡單明瞭，但是勢必在功能上有很大的限制，所以，Java引入了多型性的概念以彌補這點的不足，此外，抽象類和介面也是解決單繼承規定限制的重要手段。同時，多型也是面向物件程式設計的精髓所在。

理解多型，首先要知道“向上轉型”。

我定義了一個子類Cat，它繼承了Animal類，那麼後者就是前者是父類。我可以通過 

Cat c = new Cat(); 
例項化一個Cat的物件，這個不難理解。但當我這樣定義時： 

Animal a = new Cat(); 
這代表什麼意思呢？ 

很簡單，它表示我定義了一個Animal型別的引用，指向新建的Cat型別的物件。由於Cat是繼承自它的父類Animal，所以Animal型別的引用是可以指向Cat型別的物件的。這就是“向上轉型”。

那麼這樣做有什麼意義呢？因為子類是對父類的一個改進和擴充，所以一般子類在功能上較父類更強大，屬性較父類更獨特， 定義一個父類型別的引用指向一個子類的物件既可以使用子類強大的功能，又可以抽取父類的共性。 所以，父類型別的引用可以呼叫父類中定義的所有屬性和方法，而對於子類中定義而父類中沒有的方法，父類引用是無法呼叫的

class Father{ 
    public void func1(){ 
        func2(); 
    } 
    //這是父類中的func2()方法，因為下面的子類中重寫了該方法 
    //所以在父類型別的引用中呼叫時，這個方法將不再有效 
    //取而代之的是將呼叫子類中重寫的func2()方法 
    public void func2(){ 
        System.out.println("AAA"); 
    } 
} 
  
class Child extends Father{ 
    //func1(int i)是對func1()方法的一個過載，主要不是重寫！
    //由於在父類中沒有定義這個方法，所以它不能被父類型別的引用呼叫 
    //所以在下面的main方法中child.func1(68)是不對的 
    public void func1(int i){ 
        System.out.println("BBB"); 
    } 
    //func2()重寫了父類Father中的func2()方法 
    //如果父類型別的引用中呼叫了func2()方法，那麼必然是子類中重寫的這個方法 
    public void func2(){ 
        System.out.println("CCC"); 
    } 
} 
  
public class PolymorphismTest { 
    public static void main(String[] args) { 
        Father child = new Child(); 
        child.func1();//列印結果將會是什麼？  
        child.func1(68);
    } 
} 

class Father{   
        public void func1(){   
            func2();   
        }   
        //這是父類中的func2()方法，因為下面的子類中重寫了該方法   
        //所以在父類型別的引用中呼叫時，這個方法將不再有效   
        //取而代之的是將呼叫子類中重寫的func2()方法   
        public void func2(){   
            System.out.println("AAA");   
        }   
    }   
        
    class Child extends Father{   
        //func1(int i)是對func1()方法的一個過載，主要不是重寫！  
        //由於在父類中沒有定義這個方法，所以它不能被父類型別的引用呼叫   
        //所以在下面的main方法中child.func1(68)是不對的   
        public void func1(int i){   
            System.out.println("BBB");   
        }   
        //func2()重寫了父類Father中的func2()方法   
        //如果父類型別的引用中呼叫了func2()方法，那麼必然是子類中重寫的這個方法   
        public void func2(){   
            System.out.println("CCC");   
        }   
    }   
        
    public class PolymorphismTest {   
        public static void main(String[] args) {   
            Father child = new Child();   
            child.func1();//列印結果將會是什麼？    
            child.func1(68);  
        }   
    }

上面的程式是個很典型的多型的例子。子類Child繼承了父類Father，並重載了父類的func1()方法，重寫了父類的func2()方法。過載後的func1(int i)和func1()不再是同一個方法，由於父類中沒有func1(int i)，那麼，父類型別的引用child就不能呼叫func1(int i)方法。而子類重寫了func2()方法，那麼父類型別的引用child在呼叫該方法時將會呼叫子類中重寫的func2()。 

那麼該程式將會打印出什麼樣的結果呢？ 
很顯然，應該是“CCC”。

對於多型，可以總結以下幾點：

一、使用父類型別的引用指向子類的物件； 
二、該引用只能呼叫父類中定義的方法和變數； 
三、如果子類中重寫了父類中的一個方法，那麼在呼叫這個方法的時候，將會呼叫子類中的這個方法；（動態連線、動態呼叫） 
四、變數不能被重寫（覆蓋），”重寫“的概念只針對方法，如果在子類中”重寫“了父類中的變數，那麼在編譯時會報錯。

另轉載：

多型是通過: 
1 介面 和 實現介面並覆蓋介面中同一方法的幾不同的類體現的 
2 父類 和 繼承父類並覆蓋父類中同一方法的幾個不同子類實現的. 

一、基本概念 

多型性：傳送訊息給某個物件，讓該物件自行決定響應何種行為。 
通過將子類物件引用賦值給超類物件引用變數來實現動態方法呼叫。 

java 的這種機制遵循一個原則：當超類物件引用變數引用子類物件時，被引用物件的型別而不是引用變數的型別決定了呼叫誰的成員方法，但是這個被呼叫的方法必須是在超類中定義過的，也就是說被子類覆蓋的方法。 

1. 如果a是類A的一個引用，那麼，a可以指向類A的一個例項,或者說指向類A的一個子類。 
2. 如果a是介面A的一個引用，那麼,a必須指向實現了介面A的一個類的例項。 


二、Java多型性實現機制 

SUN目前的JVM實現機制，類例項的引用就是指向一個控制代碼（handle）的指標，這個控制代碼是一對指標： 
一個指標指向一張表格，實際上這個表格也有兩個指標（一個指標指向一個包含了物件的方法表，另外一個指向類物件，表明該物件所屬的型別）； 
另一個指標指向一塊從java堆中為分配出來記憶體空間。 

三、總結 

1、通過將子類物件引用賦值給超類物件引用變數來實現動態方法呼叫。 

DerivedC c2=new DerivedC(); 
BaseClass a1= c2; //BaseClass 基類，DerivedC是繼承自BaseClass的子類 
a1.play(); //play()在BaseClass，DerivedC中均有定義，即子類覆寫了該方法 

分析： 
* 為什麼子類的型別的物件例項可以覆給超類引用？ 
自動實現向上轉型。通過該語句，編譯器自動將子類例項向上移動，成為通用型別BaseClass； 
* a.play()將執行子類還是父類定義的方法？ 
子類的。在執行時期，將根據a這個物件引用實際的型別來獲取對應的方法。所以才有多型性。一個基類的物件引用，被賦予不同的子類物件引用，執行該方法時，將表現出不同的行為。 

在a1=c2的時候，仍然是存在兩個控制代碼，a1和c2，但是a1和c2擁有同一塊資料記憶體塊和不同的函式表。 

2、不能把父類物件引用賦給子類物件引用變數 

BaseClass a2=new BaseClass(); 
DerivedC c1=a2;//出錯 

在java裡面，向上轉型是自動進行的,但是向下轉型卻不是，需要我們自己定義強制進行。 
c1=(DerivedC)a2; 進行強制轉化,也就是向下轉型. 

3、記住一個很簡單又很複雜的規則，一個型別引用只能引用引用型別自身含有的方法和變數。 
你可能說這個規則不對的，因為父類引用指向子類物件的時候，最後執行的是子類的方法的。 
其實這並不矛盾，那是因為採用了後期繫結，動態執行的時候又根據型別去呼叫了子類的方法。而假若子類的這個方法在父類中並沒有定義，則會出錯。 
例如，DerivedC類在繼承BaseClass中定義的函式外，還增加了幾個函式（例如 myFun()） 

分析： 
當你使用父類引用指向子類的時候，其實jvm已經使用了編譯器產生的型別資訊調整轉換了。 
這裡你可以這樣理解，相當於把不是父類中含有的函式從虛擬函式表中設定為不可見的。注意有可能虛擬函式表中有些函式地址由於在子類中已經被改寫了，所以物件虛擬函式表中虛擬函式專案地址已經被設定為子類中完成的方法體的地址了。 

4、Java與C++多型性的比較 

jvm關於多型性支援解決方法是和c++中幾乎一樣的， 
只是c++中編譯器很多是把型別資訊和虛擬函式資訊都放在一個虛擬函式表中，但是利用某種技術來區別。 

Java把型別資訊和函式資訊分開放。Java中在繼承以後，子類會重新設定自己的虛擬函式表，這個虛擬函式表中的專案有由兩部分組成。從父類繼承的虛擬函式和子類自己的虛擬函式。 
虛擬函式呼叫是經過虛擬函式表間接呼叫的，所以才得以實現多型的。 

Java的所有函式，除了被宣告為final的，都是用後期繫結。 

四. 示例：1個行為,不同的物件,他們具體體現出來的方式不一樣, 
比如: 方法過載 overloading 以及 方法重寫(覆蓋)override 
class Human{ 
void run(){輸出 人在跑} 
} 
class Man extends Human{ 
void run(){輸出 男人在跑} 
} 
這個時候,同是跑,不同的物件,不一樣(這個是方法覆蓋的例子) 
class Test{ 
void out(String str){輸出 str} 
void out(int i){輸出 i} 
} 
這個例子是方法過載,方法名相同,引數表不同 

ok,明白了這些還不夠,還用人在跑舉例 
Human ahuman=new Man(); 
這樣我等於例項化了一個Man的物件,並聲明瞭一個Human的引用,讓它去指向Man這個物件 
意思是說,把 Man這個物件當 Human看了. 

比如去動物園,你看見了一個動物,不知道它是什麼, "這是什麼動物? " "這是大熊貓! " 
這2句話,就是最好的證明,因為不知道它是大熊貓,但知道它的父類是動物,所以, 
這個大熊貓物件,你把它當成其父類 動物看,這樣子合情合理. 

這種方式下要注意 new Man();的確例項化了Man物件,所以 ahuman.run()這個方法 輸出的 是 "男人在跑 " 

如果在子類 Man下你 寫了一些它獨有的方法 比如 eat(),而Human沒有這個方法, 在呼叫eat方法時,一定要注意 強制型別轉換 ((Man)ahuman).eat(),這樣才可以... 對介面來說,情況是類似的... 

例項:
    package domatic;
    //定義超類superA
    class superA {
    int i = 100;
    void fun(int j) {
    j = i;
    System.out.println("This is superA");
    }
    }
    // 定義superA的子類subB
    class subB extends superA {
    int m = 1;
    void fun(int aa) {
    System.out.println("This is subB");
    }
    }
    // 定義superA的子類subC
    class subC extends superA {
    int n = 1;
    void fun(int cc) {
    System.out.println("This is subC");
    }
    }
    class Test {
    public static void main(String[] args) {
    superA a = new superA();
    subB b = new subB();
    subC c = new subC();
    a = b;
    a.fun(100);
    a = c;
    a.fun(200);
    }
    }

例項:   
    package domatic;   
      //定義超類superA   
      class superA {   
        int i = 100;   
        void fun(int j) {   
          j = i;   
          System.out.println("This is superA");   
        }   
      }   
    // 定義superA的子類subB   
    class subB extends superA {   
       int m = 1;   
       void fun(int aa) {   
         System.out.println("This is subB");   
       }   
    }   
    // 定義superA的子類subC   
    class subC extends superA {   
      int n = 1;   
      void fun(int cc) {   
        System.out.println("This is subC");   
      }   
    }   
    class Test {   
      public static void main(String[] args) {   
        superA a = new superA();   
        subB b = new subB();   
        subC c = new subC();   
        a = b;   
        a.fun(100);   
        a = c;   
        a.fun(200);   
      }   
    }   


/* 
* 上述程式碼中subB和subC是超類superA的子類,我們在類Test中聲明瞭3個引用變數a, b, 
* c,通過將子類物件引用賦值給超類物件引用變數來實現動態方法呼叫。也許有人會問： 
* "為什麼(1)和(2)不輸出：This is superA"。 
* java的這種機制遵循一個原則：當超類物件引用變數引用子類物件時, 
* 被引用物件的型別而不是引用變數的型別決定了呼叫誰的成員方法, 
* 但是這個被呼叫的方法必須是在超類中定義過的, 
* 也就是說被子類覆蓋的方法。 
* 所以,不要被上例中(1)和(2)所迷惑,雖然寫成a.fun(),但是由於(1)中的a被b賦值, 
* 指向了子類subB的一個例項,因而(1)所呼叫的fun()實際上是子類subB的成員方法fun(), 
* 它覆蓋了超類superA的成員方法fun()；同樣(2)呼叫的是子類subC的成員方法fun()。 
* 另外,如果子類繼承的超類是一個抽象類,雖然抽象類不能通過new操作符例項化, 
* 但是可以建立抽象類的物件引用指向子類物件,以實現執行時多型性。具體的實現方法同上例。 
* 不過,抽象類的子類必須覆蓋實現超類中的所有的抽象方法, 
* 否則子類必須被abstract修飾符修飾,當然也就不能被例項化了 
*/

JAVA裡沒有多繼承，一個類之能有一個父類。而繼承的表現就是多型。一個父類可以有多個子類，而在子類裡可以重寫父類的方法（例如方法print()），這樣每個子類裡重寫的程式碼不一樣，自然表現形式就不一樣。這樣用父類的變數去引用不同的子類，在呼叫這個相同的方法print()的時候得到的結果和表現形式就不一樣了，這就是多型，相同的訊息（也就是呼叫相同的方法）會有不同的結果。舉例說明：

//父類
    public class Father{
    //父類有一個打孩子方法
    public void hitChild(){
    }
    }
    //子類1
    public class Son1 extends Father{
    //重寫父類打孩子方法
    public void hitChild(){
    System.out.println("為什麼打我？我做錯什麼了！");
    }
    }
    //子類2
    public class Son2 extends Father{
    //重寫父類打孩子方法
    public void hitChild(){
    System.out.println("我知道錯了，別打了！");
    }
    }
    //子類3
    public class Son3 extends Father{
    //重寫父類打孩子方法
    public void hitChild(){
    System.out.println("我跑，你打不著！");
    }
    }
    //測試類
    public class Test{
    public static void main(String args[]){
    Father father;
    father = new Son1();
    father.hitChild();
    father = new Son2();
    father.hitChild();
    father = new Son3();
    father.hitChild();
    }
    }

//父類   
    public class Father{   
        //父類有一個打孩子方法   
        public void hitChild(){   
        }   
    }   
    //子類1   
    public class Son1 extends Father{   
        //重寫父類打孩子方法   
        public void hitChild(){   
          System.out.println("為什麼打我？我做錯什麼了！");   
        }   
    }   
    //子類2   
    public class Son2 extends Father{   
        //重寫父類打孩子方法   
        public void hitChild(){   
          System.out.println("我知道錯了，別打了！");   
        }   
    }   
    //子類3   
    public class Son3 extends Father{   
        //重寫父類打孩子方法   
        public void hitChild(){   
          System.out.println("我跑，你打不著！");   
        }   
    }   
    //測試類   
    public class Test{   
        public static void main(String args[]){   
          Father father;   
          father = new Son1();   
          father.hitChild();   
          father = new Son2();   
          father.hitChild();   
          father = new Son3();   
          father.hitChild();   
        }   
    }

都呼叫了相同的方法，出現了不同的結果！這就是多型的表現。

上面的示例也就是工廠模式的一個簡單體現