學習向上轉型和向下轉型怎麼用沒多難，但是為什麼那樣用，我搞了很多次沒弄明白。沒弄明白的原因是平時學習時之看例子，而例子一般都比較簡單，沒有物件之間的呼叫，一般就是一個物件呼叫自己的方法。

      首先看下怎麼用轉型。

      要轉型，首先要有繼承。繼承是面嚮物件語言中一個程式碼複用的機制，簡單說就是子類繼承了父類中的非私有屬性和可以繼承的方法，然後子類可以繼續擴充套件自己的屬性及方法。

      向上轉型：子類物件轉為父類，父類可以是介面。公式：Father f = new Son();Father是父類或介面，son是子類。

       向下轉型：父類物件轉為子類。公式：Son s = (Son)f;

        例子：向上轉型

匯出類轉型為基類，在繼承圖上是向上移動的，因此一般稱為向上轉型。

            在向上轉型的過程中，子類唯一可能發生的事情是丟失方法，子類的新有的方法都會丟掉。

public class Human {

    public void speak() {
        System.out.println("I am Human");
    }

    public void work() {
        System.out.println("I am working...");
    }

    public static void main(String[] args) {
        Human h = new Male();
        h.speak();
        h.work();
        System.out.println("-----");
        Male m = new Male();
        m.sleep();
        m.speak();
    }
}

class Male extends Human {
    public void sleep() {
        System.out.println("Male sleep...");
    }

    public void speak() {
        System.out.println("I am Male");
    }
}
 

        注意：向上轉型不要強制轉型。向上轉型後父類的引用所指向的屬性是父類的屬性，如果子類重寫了父類的方法，那麼父類引用指向的或者呼叫的方法是子類的方法,這個叫動態繫結。向上轉型後父類引用不能呼叫子類自己的方法，就是父類沒有但是子類的方法，如果呼叫不能編譯通過，比如子類的sleep方法。

        非要呼叫子類的屬性呢？如果不向下轉型就需要給需要的屬性寫getter方法。

         例子：

public class Human {
    String name = "Human";

    public String getName() {
        return this.name;
    }

    public void sleep() {
        System.out.println("Human sleep..");
    }

    public static void main(String[] args) {
        Human h = new Male();
        System.out.println(h.getName());
    }
}

class Male extends Human {
    String name = "Male";

    public String getName() {
        return this.name;
    }

    public void sleep() {
        System.out.println("Male sleep..");
    }

    public void speak() {
        System.out.println("I am Male");
    }
}
 

          非要呼叫子類擴充套件的方法，比如speak方法，就只能向下轉型了。        

          例子：向下轉型   

           向下轉型需要考慮安全性，如果父類引用的物件是父類本身，那麼在向下轉型的過程中是不安全的，編譯不會出錯，但是執行時會出現java.lang.ClassCastException錯誤。它可以使用instanceof來避免出錯此類錯誤即能否向下轉型，只有先經過向上轉型的物件才能繼續向下轉型。

public class Human {
    public void sleep() {
        System.out.println("Human sleep..");
    }

    public static void main(String[] args) {
        Human h = new Male();// 向上轉型
        Human h1 = new Human();
        //h.speak();此時需要向下轉型，否則不能呼叫speak方法。
        Male m = (Male) h;
        m.speak();
        /**Male m1 = (Male)h1;
         m1.speak();    此時會出現執行時錯誤，所以可以用instanceOF判斷*/
        if (h1 instanceof Male) {
            Male m1 = (Male) h1;
            m1.speak();
        }
    }
}

class Male extends Human {
    public void sleep() {
        System.out.println("Male sleep..");
    }

    public void speak() {
        System.out.println("I am Male");
    }
}

            弄了半天，向上轉型反而不能擁有子類的全部方法，還得向下轉型，那直接Son s = new Son();豈不是很方便？不知道是不是就我一個開始學習轉型有這種想法。

            最後搞明白了，原因還是我我的例子太簡單，沒有 考慮過要把類的物件傳遞給其他函式的例子。

            例子：體現向上轉型的好處，節省程式碼。

public class Human {
    public void sleep() {
        System.out.println("Human sleep..");
    }

    public static void doSleep(Human h) {
        h.sleep();

    }//此時傳遞的引數是父類物件，但是實際呼叫時傳遞子類物件，就是向上轉型。

    public static void main(String[] args) {
        doSleep(new Male());
        //此處匿名子類物件，當然實際應用時應該是用上面的向上轉型公式，然後將子類物件傳遞進來，
        // 這樣以後好在向下轉型，此處沒有向下轉型，所以直接用了匿名類物件。
        doSleep(new Female());
    }
}

class Male extends Human {
    public void sleep() {
        System.out.println("Male sleep..");
    }
}

class Female extends Human {
    public void sleep() {
        System.out.println("Female sleep..");
    }
}

              如果不向上轉型則必須寫兩個doSleep函式，一個傳遞Male類物件，一個傳遞Female類物件。這還是兩個子類，如果有很多子類呢，就要寫很多相同的函式，造成重複。

              好，終於也理解了為什麼要向上轉型，一旦向上轉型了，當需要用到子類的方法時，就需要向下轉型，也就是為什麼要向下轉型也解決了。

總結：

1、父類引用可以指向子類物件，子類引用不能指向父類物件。

2、把子類物件直接賦給父類引用叫upcasting向上轉型，向上轉型不用強制轉型。

　　 如Father father = new Son();

3、把指向子類物件的父類引用賦給子類引用叫向下轉型（downcasting），要強制轉型,要向下轉型，必須先向上轉型為了安全可以用instanceof判斷。

　　 如father就是一個指向子類物件的父類引用，把father賦給子類引用son 即Son son =（Son）father；

　　 其中father前面的（Son）必須新增，進行強制轉換。

4、upcasting 會丟失子類特有的方法,但是子類overriding 父類的方法，子類方法有效，向上轉型只能引用父類物件的屬性，要引用子類物件屬性，則要寫getter函式。

5、向上轉型的作用，減少重複程式碼，父類為引數，調有時用子類作為引數，就是利用了向上轉型。這樣使程式碼變得簡潔。體現了JAVA的抽象程式設計思想。