java向上转型与向下转型.docx
《java向上转型与向下转型.docx》由会员分享，可在线阅读，更多相关《java向上转型与向下转型.docx（6页珍藏版）》请在冰豆网上搜索。
java向上转型与向下转型
java向上转型与向下转型
java向上转型与向下转型
java转型问题其实并不复杂，只要记住一句话：
父类引用指向子类对象。
什么叫父类引用指向子类对象，且听我慢慢道来.
从2个名词开始说起：
向上转型（upcasting）、向下转型（downcasting）.
举个例子：
有2个类，Father是父类，Son类继承自Father。
Fatherf1=newSon（）; //这就叫upcasting（向上转型）
//现在f1引用指向一个Son对象
Sons1=（Son）f1; //这就叫downcasting（向下转型）
//现在f1还是指向Son对象
第2个例子：
Fatherf2=newFather（）;
Sons2=（Son）f2; // 出错，子类引用不能指向父类对象
你或许会问，第1个例子中：
Sons1=（Son）f1;问什么是正确的呢。
很简单因为f1指向一个子类对象，Fatherf1=newSon（）;子类s1引用当然可以指向子类对象了。
而f2被传给了一个Father对象，Fatherf2=newFather（）；子类s1引用不能指向父类对象。
总结：
1。
父类引用指向子类对象，而子类引用不能指向父类对象。
2。
把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转换。
如：
Fatherf1=newSon（）;
3。
把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转换。
如：
f1就是一个指向子类对象的父类引用。
把f1赋给子类引用s1即Sons1=（Son）f1；
其中f1前面的（Son）必须加上，进行强制转换。
一、向上转型。
通俗地讲即是将子类对象转为父类对象。
此处父类对象可以是接口。
1，向上转型中的方法调用。
看下面代码：
[java]
1.package com.wensefu.others;
2.public class Animal {
3. public void eat（）{
4. System.out.println（"animal eatting..."）;
5. }
6.}
7.class Bird extends Animal{
8. public void eat（）{
9. System.out.println（"bird eatting..."）;
10. }
11. public void fly（）{
12. System.out.println（"bird flying..."）;
13. }
14.}
15.class Main{
16. public static void 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. public static void dosleep（Human h） {
24. h.sleep（）;
25. }
26.}
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.}
注意这里的向上转型：
Animalb=newBird（）;//向上转型
b.eat（）;
此处将调用子类的eat（）方法。
原因：
b实际指向的是Bird子类，故调用时会调用子类本身的方法。
需要注意的是向上转型时b会遗失除与父类对象共有的其他方法。
如本例中的fly方法不再为b所有。
2，向上转型的好处。
看上面的代码，
publicstaticvoiddosleep（Humanh）{
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. @Override
8. public void smile（） {
9. System.out.println（"MMirl smile sounds sweet..."）;
10. }
11. public void c（）{
12. System.out.println（"MMirl c（）..."）;
13. }
14.}
15.class Main{
16. public static void main（String[] args） {
17. Girl g1=new MMGirl（）; //向上转型
18. g1.smile（）;
19. MMGirl mmg=（MMGirl）g1; //向下转型,编译和运行皆不会出错
20. mmg.smile（）;
21. mmg.c（）;
22. Girl g2=new Girl（）;
23.// MMGirl mmg1=（MMGirl）g2; //不安全的向下转型,编译无错但会运行会出错
24.// mmg1.smile（）;
25.// mmg1.c（）;
26. if（g2 instanceof MMGirl）{
27. MMGirl mmg1=（MMGirl）g2;
28. mmg1.smile（）;
29. mmg1.c（）;
30. }
31. }
32.}
Girlg1=newMMGirl（）;//向上转型
g1.smile（）;
MMGirlmmg=（MMGirl）g1;//向下转型,编译和运行皆不会出错
这里的向下转型是安全的。
因为g1指向的是子类对象。
而
Girlg2=newGirl（）;
MMGirlmmg1=（MMGirl）g2;//不安全的向下转型,编译无错但会运行会出错
运行出错：
Exceptioninthread"main"java.lang.ClassCastException:
com.wensefu.other1.Girl
atcom.wensefu.other1.Main.main（Girl.java:
36）
如代码所示，可以通过instanceof来防止出现异常。
升级会员 