/**
 * 父類
 */
class Animal {
    public void eat() {
        //輸出 父類吃。。。。
    }
}
class Bird extends Animal {
    public void eat() {
        // 鳥兒吃。。。
    }
    public void fly() {
        // 鳥兒飛
    }
}
/**
 * 父類人類
 */
public class Human {
    public void sleep() {
        // 人類
    }
}
class Male extends Human {
    
 
public void sleep() {
        // 男人
    }
}
class Female extends Human {
    public void sleep() {
        // 女人
    }
}
public class Sys {
    public static void main(String[] args) {
        Animal b = new Bird(); //向上轉型  
        b.eat();
        //  b.fly(); b雖指向子類對象，但此時子類作為向上的代價丟失和父類不同的fly()方法  
        sleep(new
 
 Male());
        sleep(new Female()); //傳入的參數是子類-----！！  
    }
    public static void sleep(Human h) //方法的參數是父類------！！！  
        {
            h.sleep();
        }
}

子類重寫的父類的 eatting...
男人 sleep..
女人 sleep..

詳解：

1. 向上轉型的實現

Animal b=new Bird(); //向上轉型
b.eat(); // 調用的是子類的eat()方法
b.fly(); // 報錯!!!!!-------b雖指向子類對象，但此時子類作為向上轉型的代價丟失和父類不同的fly()方法------
2.為何不直接Bird b=new Bird();b.eat() 呢？

這樣就沒有體現出面向對象的抽象的編程思想呀，降低了代碼的可擴展性.

3.向上轉型的好處？

sleep(new Male());//調用方法時傳入的參數是子類
sleep(new Female());

public static void sleep(Human h) //方法的參數是父類

{

h.sleep();

}

如上代碼就是用的向上轉型，若是不用向上轉型，那麽有多少個子類就得在這兒寫多少種不同的睡覺方法~~~~~~

 class Fruit {
     public void myName() {
         // 水果
     }
 }

 class Apple extends Fruit {
     public void myName() {
         // 蘋果
     }
     public void myMore() {
         蘋果1233333
     }
 }

 public class Sys {
     public static void main(String[] args) {
         Fruit a = new Apple(); //向上轉型  
         a.myName();

         Apple aa = (Apple) a; //向下轉型,編譯和運行皆不會出錯(正確的)  
         aa.myName(); //向下轉型時調用的是子類的  
         aa.myMore();;

         Fruit f = new Fruit();
         Apple aaa = (Apple) f; //-不安全的---向下轉型,編譯無錯但會運行會出錯  
         aaa.myName();
         aaa.myMore();
     }
 }

我是子類 蘋果...
我是子類 蘋果...
我是你的小呀小蘋果~~~~~~
出錯。。。。。。。。

詳解：

1.正確的向下轉型

Fruit a=new Apple(); //向上轉型
a.myName();
Apple aa=(Apple)a; //向下轉型,編譯和運行皆不會出錯(正確的)
aa.myName();
aa.myMore();

a指向子類的對象，所以子類的實例aa也可以指向a啊~~

向下轉型後因為都是指向子類對象，所以調用的當然全是子類的方法~~

2.不安全的向下轉型

Fruit f=new Fruit();
Apple aaa=(Apple)f; //-不安全的---向下轉型,編譯無錯但會運行會出錯
aaa.myName();
aaa.myMore();

f是父類對象，子類的實例aaa肯定不能指向父類f啊~~~

3.Java為了解決不安全的向下轉型問題，引入泛型的概念

4.為了安全的類型轉換，最好先用 if(A instanceof B) 判斷一下下~~

轉型（java）（.net）