java 向上转型和向下转型

向上转型（通俗的说 将子类型转换为父类型）

public class Fruit{
    public void eat(){
        System.out.println("fruit eating");
    }
}

public class Apple extends Fruit{
    private String name ;

    @Override
    public void eat() {
        System.out.println("apple eating");
    }

    public void callName(){
        System.out.println("my name is:"+ name);
    }
}

public class Test{
    public static void main(String [] args){
        //向上转型
        Fruit f = new Apple();
        f.eat(); 
        //f.callName(); 无法调用

        //向下转型
        Fruit f2 = new Apple();
        Apple apple2 = (Apple) f2 ;
        //但下面这么做是错误的  子引用不能指向父类对象
        Fruit f3 = new Fruit();
        Apple apple3 = (Apple) f3 ;

    }
}

注意
1. 父类引用指向子类对象，子类引用不能指向父类对象
2. 把子类对象赋给父类引用叫向上转型，不用强制转换
当父类引用指向子类对象时，子类对象的类型而不是父类引用的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在父类中定义过的，也就是说被子类覆盖的方法，但是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
3. 把指向子类对象的父类引用赋给子类引用，需要强制转换

有啥好处

public void invokeEat(Fruit f){
    f.eat();
}

比如在使用上面的例子时，如果参数是具体的子类，那有多少个子类就要有多少的调用方法，显然那样做太麻烦。这样做，可以很容易的添加多个子类，也不需要增加任何的代码，方便扩展。

为了更好理解：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O) 看下面这个例子

public class A{
    public String show(D obj){
        return ("A and D");
    }

    public String show(A obj){
        return ("A and A");
    }
}

public class B extends A{

    public String show(B obj){
        return ("B and B");
    }

    public String show(A obj){
        return ("B and A");
    }
}

public class C extends B {

}

public class D extends B {

}

public class Test {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();

        System.out.println("1--"+ a1.show(b));
        System.out.println("2--"+ a1.show(c));
        System.out.println("3--"+ a1.show(d));
        System.out.println("4--"+ a2.show(b));
        System.out.println("5--"+ a2.show(c));
        System.out.println("6--"+ a2.show(d));
        System.out.println("7--"+ b.show(b));
        System.out.println("8--"+ b.show(c));
        System.out.println("9--"+ b.show(d));
        //输出的结果
        1--A and A
        2--A and A
        3--A and D
        4--B and A
        5--B and A
        6--A and D
        7--B and B
        8--B and B
        9--A and D
}