向上转型和向下转型

简单使用

声明一个父类Father,子类Son继承Father

Father a = new Son()  // 父类引用、子类对象（向上转型）

Son b = (Son)a  //  向下转型，强制转换
// 父类引用转成子类引用

向上转型实例

public class Animal {
  
  public void eat(){
    System.out.println("animal eatting...");
  }
}
class Bird extends Animal{
  
  public void eat(){
    System.out.println("bird eatting...");
  }
  
  public void fly(){
    
    System.out.println("bird flying...");
  }
}
class Main{
  
  public static void main(String[] args) {
    
    Animal b=new Bird(); //向上转型
    b.eat(); // 调用的是子类eat()
    //! error: b.fly();
    //  b虽指向子类对象，但此时子类做为向上转型的代价丢失和父类不一样的fly()方法------
    dosleep(new Male());
    dosleep(new Female());
  }
  
  public static void dosleep(Human h) {
    h.sleep();
  }
}

public class Human {
  public void sleep() {
    System.out.println("Human sleep..");
  }
}
class Male extends Human {
  @Override
  public void sleep() {
    System.out.println("Male sleep..");
  }
}
class Female extends Human {
  @Override
  public void sleep() {
    System.out.println("Female sleep..");
  }
}

这里就能够看出向上转型的好处和使用场景了

public static void dosleep(Human h) {
    h.sleep();
}

这里的参数类型是父类，传入的值是子类，这就完成了向上转型操做。而后会自动判断调用该子类的对应方法。试想，若是咱们这么干

public static void dosleep(Male male) {
    male.sleep();
}

public static void dosleep(Female fe) {
    fe.sleep();
}

......

这是人，要换成水果，给你来个几百种，不写死才怪。
所以向上转型很好的简化了代码，也正是体现了java的抽象编程思想，使代码变得解耦。

向下转型实例

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();//向下转型时调用的是子类的

a指向子类的对象，因此子类的实例aa也能够指向a

向下转型后由于都是指向子类对象，因此调用的固然全是子类的方法

1. 错误的向下转型

Fruit f=new Fruit();
        Apple aaa=(Apple)f; //-不安全的---向下转型,编译无错但会运行会出错
        aaa.myName();
        aaa.myMore();

这里f指向父类对象，子类实例确定不能指向f

3.Java为了解决不安全的向下转型问题，引入泛型的概念

4.为了安全的类型转换，最好先用 if(A instanceof B) 判断一下对象类型

例：

if (f instanceof Apple){
    Apple aaa=(Apple)f;
        aaa.myName();
        aaa.myMore(); 
}

参考文章：https://blog.csdn.net/sheepmu/article/details/38327205