向上和向下转型

前言

复习Java时，以前对上下两种转型有所模糊，特此立帖，方便查看。

向上转型

• 向上转型后父类的引用所指向的属性是父类的属性，如果子类重写了父类的方法，那么父类引用指向的或者调用的方法是子类的方法,这个叫动态绑定。
• 其他特点没有实际意义，哦呵呵

向下转型

• 在java中,向下转型则是为了,通过父类强制转换为子类,从而来调用子类独有的方法(扩展的方法)
• 如果父类引用的对象是父类本身(A a = new A(); )，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误即能否向下转型，只有先经过向上转型的对象才能继续向下转型。
  ClassCastException错误

public class DownTransition {
    public static void main(String[] args) {
        A a = new A();
        B b = (B)a;
        b.print();
    }
}

class A {
    public void print(){
        System.out.println("我是爹");
    }
}
class B extends A{
    @Override
    public void print() {
        System.out.println("我是儿子");
    }
    public void uniqueMethod(){
        System.out.println("儿子的独有方法");
    }
}

正确做法

public class DownTransition {
    public static void main(String[] args) {
        A a = new B();
        if(a instanceof B){
            B b = (B)a;
            b.print();//不论是是向上转型还是向下转型，只要被覆盖就是调用子类的方法
            b.uniqueMethod();//儿子的独有方法
        }

    }
}

class A {
    public void print(){
        System.out.println("我是爹");
    }
}
class B extends A{
    @Override
    public void print() {
        System.out.println("我是儿子");
    }
    public void uniqueMethod(){
        System.out.println("儿子的独有方法");
    }
}

一个有意思的现象

public class DownTransition {
    public static void main(String[] args) {
        A a = new B();
        if(a instanceof B)//返回true
            System.out.println("我既是A的实例");

        if(a instanceof A)//返回true
            System.out.println("我还是B的实例");
        if(!(a instanceof C))//直接无法通过编译
            System.out.println("但我不是C的实例");
    }
}

class A {
    public void print(){
        System.out.println("我是爹");
    }
}
class B extends A{
    @Override
    public void print() {
        System.out.println("我是儿子");
    }
    public void uniqueMethod(){
        System.out.println("儿子的独有方法");
    }
}
class C{

}

网上的朋友给出的意见是：

编译器会检查 对象 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。