Java向上轉型和向下轉型（附詳細例子）
熬夜整理的關於Java向上和向下轉型的例子，非常的通俗易懂哦~~~~
一.向上轉型
package com.sheepmu;
class Animal
{
public void eat()
{
System.out.println("父類的 eating...");
}
}
class Bird extends Animal
{
@Override
public void eat()
{
System.out.println("子類重寫的父類的 eatting...");
}
public void fly()
{
System.out.println("子類新方法 flying...");
}
}
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();
}
} package com.sheepmu;
public class Human
{
public void sleep()
{
System.out.println("父類人類 sleep..");
}
}
class Male extends Human
{
@Override
public void sleep()
{
System.out.println("男人 sleep..");
}
}
class Female extends Human
{
@Override
public void sleep()
{
System.out.println("女人 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();
}
如上代碼就是用的向上轉型，若是不用向上轉型，那麼有多少個子類就得在這兒寫多少種不同的睡覺方法~~~~~~
二.向下轉型
package com.sheepmu;
class Fruit
{
public void myName()
{
System.out.println("我是父類 水果...");
}
}
class Apple extends Fruit
{
@Override
public void myName()
{
System.out.println("我是子類 蘋果...");
}
public void myMore()
{
System.out.println("我是你的小呀小蘋果~~~~~~");
}
}
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();
}
}我是子類 蘋果...
我是子類 蘋果...
我是你的小呀小蘋果~~~~~~
Exception in thread "main" java.lang.ClassCastException: com.sheepmu.Fruit cannot be cast to com.sheepmu.Apple
at com.sheepmu.Sys.main(Sys.java:30)
詳解：
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) 判斷一下下~~
