java中的向上转型和向下转型

原文地址：https://blog.csdn.net/fangtengfei/article/details/72810560
一.向上转型

 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();  
        }  
}

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();

         }

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

二.向下转型

 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) 判断一下下~~

总结：
1、父类引用可以指向子类对象，子类引用不能指向父类对象。

2、把子类对象直接赋给父类引用叫向上转型，向上转型不用强制转型。

3、把指向子类对象的父类引用赋给子类引用叫向下转型，要强制转型。

4、向上转型会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效

5、向上转型的作用，减少重复代码，父类做为参数，调用时子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象面向对象编程。

转载自：https://blog.csdn.net/fangtengfei/article/details/72810560