Java中向上转型和向下转型的问题

一、向上转型

通俗地讲即是将子类对象转为父类对象。此处父类对象可以是接口。

1、向上转型中的方法调用

实例

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 doEat(Animal h) {
    h.eat();
  }
  public static void main(String[] args) {
    
    Animal b=new Bird(); //向上转型
    b.eat(); 
    //! error: b.fly(); b虽指向子类对象，但此时丢失fly()方法
    Animail c1=new Animal();
    Bird c2=new Bird();
    doEat(c1);
    doEat(c2);//此处参数存在向上转型
  }
}

注意这里的向上转型：

Animal b=new Bird(); //向上转型
b.eat();

此处将调用子类的 eat() 方法。原因：b 实际指向的是 Bird 子类，故调用时会调用子类本身的方法。

需要注意的是向上转型时 b 会遗失除与父类对象共有的其他方法。 如本例中的 fly 方法不再为 b 所有。还有需要值得注意的是！当子类向上转型之后调用成员变量即实例变量是父类的，调用的成员方法是子类的！

2、向上转型的作用

看上面的代码：
public static void doEate(Animail h) { h.sleep(); }
这里以父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。不然的话，如果 doEate 以子类对象为参数，则有多少个子类就需要写多少个函数。这也体现了 JAVA 的抽象编程思想。

二、向下转型。

与向上转型相反，即是把父类对象转为子类对象。

1、向下转型中的方法调用

实例

public class Animail {
    private String name="Animail";
    public void eat(){
        System.out.println(name+" eate");
    }
}

class Human extends Animail{
    private String name="Human";
    public void eat(){
        System.out.println(name+" eate");
    }
}

class Main {
    public static void main(String[] args) {
        Animail a1=new Human();//向上转型
        Animail a2=new Animail();
        Human b1=(Human)a1;// 向下转型,编译和运行皆不会出错
 //       Human c=(Human)a2;//不安全的向下转型,编译无错但会运行会出错
    }
}

Animail a1=new Human();//向上转型
Human b1=(Human)a1;// 向下转型,编译和运行皆不会出错

这里的向下转型是安全的。因为 a1 指向的是子类对象。

而
Animail a2=new Animail();
Human c=(Human)a2;//不安全的向下转型,编译无错但会运行会出错

运行出错：

Exception in thread "main" java.lang.ClassCastException: study. 转型实例.Animail cannot be cast to study.转型实例.Human at study.转型实例.Main.main(Main.java:8)

2、向下转型的作用

向上转型时 b会遗失除与父类对象共有的其他方法；可以用向下转型在重新转回，这个和向上转型的作用要结合理解。

三、当转型遇到重写和同名数据

看下面一个例子，你觉得它会输出什么？

public class A {
	   public int i=10;
	   void print(){
	       System.out.println("我是A中的函数");
	   }
	}
	class B extends A{
	   public int i=20;
	    void print(){
	        System.out.println("我是B中的函数，我重写了A中的同名函数");
	    }
	    void speak(){
	        System.out.println("向上转型时我会丢失");
	    }

	   public static void main(String[] args) {
	        B b=new B();
	        A a=b;//此处向上转型
	        b.print();  System.out.println(b.i);
	        b.speak();
	        a.print();  System.out.println(a.i);
	        //a.speak(); 报错
	       ((B) a).speak();//a在创建时虽然丢失了speak方法但是向下转型又找回了
	    }
	}

结果

我是B中的函数，我重写了A中的同名函数
20
向上转型时我会丢失
我是B中的函数，我重写了A中的同名函数
10
向上转型时我会丢失

我们发现同名数据是根据创建对象的对象类型而确定，而这个子类重写的函数涉及了多态，重写的函数不会因为向上转型而丢失

四、多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象

所以不要弄混淆了，父类的方法在重写后会被子类覆盖，当需要在子类中调用父类的被重写方法时，要使用super关键字