Java向上转型和向下转型（附详细例子）

熬夜整理的关于Java向上和向下转型的例子，非常的通俗易懂哦~~~~

一.向上转型

[java]  view plain  copy

1. package com.sheepmu;  
2.  class Animal  
3.  {  
4.     public void eat()  
5.     {  
6.         System.out.println("父类的 eating...");  
7.     }  
8. }  
9. class Bird extends Animal  
10. {     
11.     @Override  
12.     public void eat()  
13.     {  
14.         System.out.println("子类重写的父类的  eatting...");  
15.     }     
16.     public void fly()  
17.     {  
18.         System.out.println("子类新方法  flying...");  
19.     }  
20. }  
21. public class Sys  
22. {  
23.     public static void main(String[] args)   
24.     {  
25.         Animal b=new Bird(); //向上转型  
26.         b.eat();   
27.         //  b.fly(); b虽指向子类对象，但此时子类作为向上的代价丢失和父类不同的fly()方法  
28.         sleep(new Male());  
29.         sleep(new Female());//传入的参数是子类-----！！  
30.     }  
31.       
32.     public static void sleep(Human h) //方法的参数是父类------！！！  
33.         {  
34.          h.sleep();  
35.         }  
36. }                          

[java]  view plain  copy

1. package com.sheepmu;  
2.    
3. public class Human   
4. {  
5.     public void sleep()   
6.     {  
7.         System.out.println("父类人类   sleep..");  
8.     }  
9. }  
10. class Male extends Human  
11. {  
12.     @Override  
13.     public void sleep()   
14.     {  
15.         System.out.println("男人 sleep..");  
16.     }  
17. }  
18. class Female extends Human   
19. {  
20.     @Override  
21.     public void sleep()  
22.     {  
23.         System.out.println("女人 sleep..");  
24.     }  
25. }  
26.                           

输出：

子类重写的父类的  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();

             }

如上代码就是用的向上转型，若是不用向上转型，那么有多少个子类就得在这儿写多少种不同的睡觉方法~~~~~~

二.向下转型

[java]  view plain  copy

1. package com.sheepmu;  
2.  class Fruit  
3.   {  
4.     public void myName()  
5.     {  
6.         System.out.println("我是父类  水果...");  
7.     }  
8. }  
9.    
10. class Apple extends Fruit  
11. {   
12.     @Override  
13.     public void myName()   
14.     {   
15.         System.out.println("我是子类  苹果...");  
16.     }  
17.     public void myMore()  
18.     {  
19.         System.out.println("我是你的小呀小苹果~~~~~~");  
20.     }  
21. }  
22.   
23. public class Sys{   
24.     public static void main(String[] args) {   
25.         Fruit a=new Apple(); //向上转型  
26.         a.myName();  
27.           
28.         Apple aa=(Apple)a; //向下转型,编译和运行皆不会出错(正确的)  
29.         aa.myName();//向下转型时调用的是子类的  
30.         aa.myMore();;  
31.             
32.         Fruit f=new Fruit();  
33.         Apple aaa=(Apple)f; //-不安全的---向下转型,编译无错但会运行会出错  
34.         aaa.myName();  
35.         aaa.myMore();   
36.     }  
37. }  

输出：

我是子类  苹果...
我是子类  苹果...
我是你的小呀小苹果~~~~~~
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) 判断一下下~~