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
}