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. }
32. public static void sleep(Human h) //方法的参数是父类------！！！
33. {
34. h.sleep();
35. }
36. }

[java] view plain copy

1. package com.sheepmu;
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. }

输出：

子类重写的父类的 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. }
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. }
23. public class Sys{
24. public static void main(String[] args) {
25. Fruit a=new Apple(); //向上转型
26. a.myName();
28. Apple aa=(Apple)a; //向下转型,编译和运行皆不会出错(正确的)
29. aa.myName();//向下转型时调用的是子类的
30. aa.myMore();;
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) 判断一下下~~