一、向上轉型。

通俗地講即是將子類物件轉為父類物件。此處父類物件可以是介面。

1，向上轉型中的方法呼叫。

看下面程式碼：

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

 

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

注意這裡的向上轉型：

        Animal b=new Bird(); //向上轉型
        b.eat();

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

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

2，向上轉型的好處。

看上面的程式碼，

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

這裡以父類為引數，調有時用子類作為引數，就是利用了向上轉型。這樣使程式碼變得簡潔。不然的話，
如果dosleep以子類物件為引數，則有多少個子類就需要寫多少個函式。這也體現了JAVA的抽象程式設計思想。

二、向下轉型。

與向上轉型相反，即是把父類物件轉為子類物件。

看下面程式碼：

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

 

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
    at com.wensefu.other1.Main.main(Girl.java:36)
如程式碼所示，可以通過instanceof來防止出現異常。

轉自http://blog.sdn.net/luqiang454171826/article/details/6136540

一、向上轉型。

通俗地講即是將子類物件轉為父類物件。此處父類物件可以是介面。

1，向上轉型中的方法呼叫。

看下面程式碼：

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

 

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

注意這裡的向上轉型：

        Animal b=new Bird(); //向上轉型
        b.eat();

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

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

2，向上轉型的好處。

看上面的程式碼，

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

這裡以父類為引數，調有時用子類作為引數，就是利用了向上轉型。這樣使程式碼變得簡潔。不然的話，
如果dosleep以子類物件為引數，則有多少個子類就需要寫多少個函式。這也體現了JAVA的抽象程式設計思想。

二、向下轉型。

與向上轉型相反，即是把父類物件轉為子類物件。

看下面程式碼：

1. package com.wensefu.other1;  
2. publicclass Girl {  
3.     publicvoid smile(){  
4.         System.out.println("girl smile()...");  
5.     }  
6. }  
7. class MMGirl extends Girl{  
8.     @Override
9.     publicvoid smile() {  
10.         System.out.println("MMirl smile sounds sweet...");  
11.     }  
12.     

    相關推薦

    java中向上轉型(upcast)和向下轉型(downcast)

    abstract class ClassAbstract1{}class ClassDerived1 extends ClassAbstract1{ public void play1() {  System.out.println("play1() is in the ClassDerived1"); }}

    Java中的向上型別轉換和向下型別轉換

    一、向上轉型。 通俗地講即是將子類物件轉為父類物件。此處父類物件可以是介面。 1，向上轉型中的方法呼叫。 看下面程式碼： package com.wensefu.others;   publicclass Animal {           publicv

    3.sql中的向上遞歸和向下遞歸

    ble 編碼 conn table where 包含 span 順序 ffffff 1.向下遞歸 select * from table_name where 條件 connect by prior bmbm(本級關聯條件)=sjbmbm(上級關聯條件) start wit

    向上取整和向下取整（ceil round）

    分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

    Swift Double向上取整和向下取整、Double轉Int/String

    floor()函式：向下取整，取小於等於這個數的最大整數 (floor(3.94) = 3) ceil()函式：向上取整，取大於等於這個數的最小整數 (ceil(3.14) = 4) import Foundation extension Double { func int

    向上取整和向下取整

    C語言有以下幾種取整方法： 1、直接賦值給整數變數。如： int i = 2.5; 或 i = (int) 2.5; 這種方法採用的是捨去小數部分 2、C/C++中的整數除法運算子“/”本身就有取整功能(int / int)，但是整數除法對負數的取整結果和使用的C編

    java語言機制中的多型多型理解以及多型的向上轉型和向下轉型問題

    多型中轉型問題往往不容易理解，特別是向上和向下轉型。 下面先說說多型的概念和前提： 1.要有繼承關係； 2.要有方法重寫； 3.要有父類引用指向子類物件； 如果是成員變數的話，編譯看左邊（父類），執行看左邊（子類）； 如果是成員方法的話，編譯看左邊（父類），執行看右邊（子類）

    Java多型中的向上轉型和向下轉型

    向上轉型:將一個父類的引用指向一個子類物件，稱為向上轉型，自動進行型別轉換     用法: Father f = new Son（）； 向下轉型：子類引用指向父類引用的子類物件  通俗的說就是子類例項物件賦值給父類引用，然後父類引用又要賦值給子類引用，這個過程就是向下轉型

    物件型別的轉換（向上轉型和向下轉型）

    1 //父類 2 class Parent 3 { 4 public static String kind="javastudy.extendsstudy.parent"; 5 public static int age=50; 6 pu

    c++中向上轉型和向下轉型，動態轉換，和靜態轉換詳解

    子類轉換為父類：向上轉型，使用dynamic_cast<type_id>(expression)，這種轉換相對來說比較安全不會有資料的丟失； 父類轉換為子類：向下轉型，可以使用強制轉換，這

    JavaSE（五）JAVA對象向上轉型和向下轉型

    open 其他 解釋 編譯 -- 運行出錯 instance xtend args 今天做了一個測試的題目，發現自己還是很多問題沒有靜下心來做。很多問題是可以自己解決的但是自己一是沒有讀清題意，二是自己心裏太急躁了。所以這個要自己應以為鑒！ 對象的轉型問題其實並不復雜，我

    JAVA向上轉型和向下轉型

    子類 font new ont java向上轉型 clas 之間 string output 　　最近在看JAVA編程思想，之前學的JAVA只能算是皮毛，大概看到第七章繼承時出現了個名詞-向上轉型。所以就來討論下向上和向下轉型的內容和意義，內容會隨著我看書的進度一直更新的

    JAVA 異常向上拋和向下拋的優劣勢

    總結 bsp java 方便 優劣勢 拋出異常 出現 不能 解決 向上拋： 優點：向上拋出異常，下面代碼清秀； 缺點：不能直接看出拋出異常的代碼； 向下拋： 優點：能直接看到出現異常的代碼，方便查找，顯得嚴謹； 缺

    基本數據類型轉換之向上轉型和向下轉換

    顯式 上轉型 類型轉化 基本 轉換 字符 隱式 nbsp 相互 向上轉換： 整型，字符型，浮點型的數據在混合運算中相互轉換，轉換時遵循以下原則： 容量小的類型可自動轉換為容量大的數據類型； byte,short,char → int → long → float → dou

    JAVA的向上轉型 和 向下轉型

    向上轉型 是面向物件繼承的一種形式，是指子類物件轉換為父類物件。 看下面的example class Instrument { public void play() { System.out.println("Instrument play"); }

    java——向上轉型和向下轉型

    Father f1 = new Son(); // 這就叫 upcasting （向上轉型) // 現在 f1 引用指向一個Son物件 Son s1 = (Son)f1; // 這就叫 downcasting (向下轉型) // 現在f1 還是指向 Son物件 Father f2 =

    java學習-向上轉型和向下轉型

    一，多型 在設計一個方法的時候，通常希望該方法具備一定的通用性。比如實現一個動物叫的方法，每個動物的叫聲是不一樣的，可以在方法中接收一個動物型別的引數，當傳入貓類物件的時候就發出喵的聲音，相對傳入狗的物件就發出汪的聲音。同一個方法這種應為引數不同而導致執行效果不同的現象叫做

    面向物件中的多型,物件的向上轉型和向下轉型

    多型 首先什麼是多型? 多型就是一種事物的多種形態. 建立多型的前提需要滿足三個條件: 1.首先類與類之間要建立聯絡,即需要有繼承關係 2.子類中一定要有方法的重寫 3.最重要的是一定要有父類的指標指向子類的物件或者說父類的引用指向子類的空間 下面

    關於Java繼承的 向上轉型和向下轉型

    在Java中， 向上轉型（upcasting）和向下轉型（downcasting）的前提，必須是有“繼承關係”，向上轉型是自動的，向下轉型需要進行強轉。 例如： /**定義了一個“父”類*/ public class Father { /**姓名

    Java 向下型別轉換

    public class Test { public static void main(String[] args) { Parent p = new Child(); Child child = (Child) p