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

不变真理：父类引用指向子类对象。
有2个类，Father是父类，Childern类继承Father类。
// upcasting （向上转型)

Father f1= new Childern(); // f1引用指向一个Childern对象
//  downcasting (向下转型) 

Childern c1 = (Childern)f1; // f1还是指向Childern对象
Father f2 = new Father();

Childern c2 = (Childern)f2; // 出错，子类引用不能指向父类对象

那么 Childern c1 = (Childern)f1 可以，为什么 Childern c2 = (Childern)f2 不可以呢？。

因为f1指向Childern 对象，Father f1 = new Childern(); 子类s1引用当然可以指向子类对象了。

f2 指向Father对象，Father f2 = new Father（）；子类s1引用不能指向父类对象。

总结：

1、父类引用指向子类对象，而子类引用不能指向父类对象。

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

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

向上转型例子：
 

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();
        //! 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..");
    }
}

注意这个的向上转型 Animal b=new Bird(); 
此处将调用Bird的eat()方法。原因：b实际指向的是Bird子类，故调用时会调用子类本身的方法。
但是向上转型时b会遗失除与父类对象共有的其他方法。如本例中的fly方法不再为b所有。

向上转型的好处：
dosleep方法为例子，这里用父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。不然的话，
如果dosleep以子类对象为参数，则有多少个子类就需要写多少个函数。这也体现了JAVA的抽象编程思想。

向下转型例子：
 

public class Girl {
    public void smile(){
        System.out.println("girl smile()...");
    }
}
class MMGirl extends Girl{
    @Override
    public void smile() {
        System.out.println("MMirl smile sounds sweet...");
    }
    public void c(){
        System.out.println("MMirl c()...");
    }
}
class Main{
    public static void main(String[] args) {
        Girl g1=new MMGirl(); //向上转型
        g1.smile();

        MMGirl mmg=(MMGirl)g1; //向下转型,编译和运行皆不会出错
        mmg.smile();
        mmg.c();

        Girl g2=new Girl();
        // MMGirl mmg1=(MMGirl)g2; //不安全的向下转型,编译无错但会运行会出错
        // mmg1.smile();
        // mmg1.c();

        if(g2 instanceof MMGirl){
            MMGirl mmg1=(MMGirl)g2;
            mmg1.smile();
            mmg1.c();
        }
    }
}

MMGirl mmg=(MMGirl)g1; //向下转型,编译和运行皆不会出错
这里的向下转型是安全的。因为g1指向的是子类对象。
Girl g2=new Girl();
MMGirl mmg1=(MMGirl)g2; //不安全的向下转型,编译无错但会运行会出错
可以通过instanceof来防止出现异常。