Java中的向下轉型與向上轉型

java轉型問題其實並不複雜，只要記住一句話：父類引用指向子類對象。

什麼叫父類引用指向子類對象，且聽我慢慢道來.

從2個名詞開始說起：向上轉型(upcasting)、向下轉型(downcasting).

舉個例子：有2個類，Father是父類，Son類繼承自Father。

Father f1 = newSon();   // 這就叫upcasting （向上轉型)

// 現在f1引用指向一個Son對象

Son s1 =(Son)f1;   // 這就叫downcasting (向下轉型)

// 現在f1還是指向Son對象

第2個例子：

Father f2 = newFather();

Son s2 =(Son)f2;      //出錯，子類引用不能指向父類對象

你或許會問，第1個例子中：Son s1 = (Son)f1;問什麼是正確的呢。

很簡單因爲f1指向一個子類對象，Father f1 = newSon(); 子類s1引用當然可以指向子類對象了。

而f2 被傳給了一個Father對象，Father f2 = newFather（）；子類s1引用不能指向父類對象。

總結：

1。父類引用指向子類對象，而子類引用不能指向父類對象。

2。把子類對象直接賦給父類引用叫upcasting向上轉型，向上轉型不用強制轉換。

     如：Father f1 = new Son();

3。把指向子類對象的父類引用賦給子類引用叫向下轉型(downcasting)，要強制轉換。

   如：f1就是一個指向子類對象的父類引用。把f1賦給子類引用s1即 Son s1 =(Son)f1；

          其中f1前面的(Son)必須加上，進行強制轉換。

一、向上轉型。

通俗地講即是將子類對象轉爲父類對象。此處父類對象可以是接口。

1，向上轉型中的方法調用。

看下面代碼：

[java]

1. package com.wensefu.others;  
2. public class Animal {  
3.       
4.     public void eat(){  
5.         System.out.println("animal eatting...");  
6.     }  
7. }  
8. class Bird extends Animal{  
9.       
10.     public void eat(){  
11.         System.out.println("bird eatting...");  
12.     }  
13.       
14.     public void fly(){  
15.           
16.         System.out.println("bird flying...");  
17.     }  
18. }  
19. class Main{  
20.       
21.     public static void main(String[] args) {  
22.           
23.         Animal b=new Bird(); //向上轉型  
24.         b.eat();   
25.         //! error: b.fly(); b雖指向子類對象，但此時丟失fly()方法  
26.         dosleep(new Male());  
27.         dosleep(new Female());  
28.     }  
29.       
30.     public static void dosleep(Human h) {  
31.         h.sleep();  
32.     }  
33. }  
34.                           

package com.wensefu.others;  

1. public class Human {  
2.     public void sleep() {  
3.         System.out.println("Human sleep..");  
4.     }  
5. }  
6. class Male extends Human {  
7.     @Override  
8.     public void sleep() {  
9.         System.out.println("Male sleep..");  
10.     }  
11. }  
12. class Female extends Human {  
13.     @Override  
14.     public void sleep() {  
15.         System.out.println("Female sleep..");  
16.     }  
17. }  
18.                           

注意這裏的向上轉型：
       Animal b=newBird(); //向上轉型
      b.eat();

此處將調用子類的eat()方法。原因：b實際指向的是Bird子類，故調用時會調用子類本身的方法。

需要注意的是向上轉型時b會遺失除與父類對象共有的其他方法。如本例中的fly方法不再爲b所有。

2，向上轉型的好處。

看上面的代碼，

   public static void dosleep(Human h) {
      h.sleep();
    }

這裏以父類爲參數，調有時用子類作爲參數，就是利用了向上轉型。這樣使代碼變得簡潔。不然的話，
如果dosleep以子類對象爲參數，則有多少個子類就需要寫多少個函數。這也體現了JAVA的抽象編程思想。

二、向下轉型。

與向上轉型相反，即是把父類對象轉爲子類對象。

看下面代碼：

package com.wensefu.other1;  

1. public class Girl {  
2.     public void smile(){  
3.         System.out.println("girl smile()...");  
4.     }  
5. }  
6. class MMGirl extends Girl{  
7.       
8.     @Override  
9.     public void smile() {  
10.           
11.         System.out.println("MMirl smile sounds sweet...");  
12.     }  
13.     public void c(){  
14.         System.out.println("MMirl c()...");  
15.     }  
16. }  
17. class Main{  
18.       
19.     public static void main(String[] args) {  
20.           
21.         Girl g1=new MMGirl(); //向上轉型  
22.         g1.smile();  
23.           
24.         MMGirl mmg=(MMGirl)g1; //向下轉型,編譯和運行皆不會出錯  
25.         mmg.smile();  
26.         mmg.c();  
27.           
28.           
29.         Girl g2=new Girl();  
30. //      MMGirl mmg1=(MMGirl)g2; //不安全的向下轉型,編譯無錯但會運行會出錯  
31. //      mmg1.smile();  
32. //      mmg1.c();  
33.   
34.         if(g2 instanceof MMGirl){  
35.             MMGirl mmg1=(MMGirl)g2;   
36.             mmg1.smile();  
37.             mmg1.c();  
38.         }  
39.           
40.     }  
41. }  

Girl g1=new MMGirl(); //向上轉型
      g1.smile();
      MMGirl mmg=(MMGirl)g1; //向下轉型,編譯和運行皆不會出錯

這裏的向下轉型是安全的。因爲g1指向的是子類對象。

而
Girl g2=new Girl();
MMGirl mmg1=(MMGirl)g2; //不安全的向下轉型,編譯無錯但會運行會出錯

運行出錯：

Exception in thread "main"java.lang.ClassCastException: com.wensefu.other1.Girl
    atcom.wensefu.other1.Main.main(Girl.java:36)
如代碼所示，可以通過instanceof來防止出現異常。