java基础之向上转型与向下转型

一个事物的出现意味着他要去解决什么问题或者是衍生物，有时候大家不知道向上转型的意义，或者是说只是了解一个大概。那么我将详细给大家介绍一波。

名称	功能	例子
向上转型（upCast）	通过子类实例化父类	A a=new B()
向下转型（downCast）	通过父类实例化子类	B b=new A()

先敲一波代码，再和大家解释

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

class A {
    public void method0() {
        System.out.println("A::method0");
    }
    public void method() {
        System.out.println("A:method");
    }
}

class B extends A {
    @Override
    public void method0() {
        System.out.println("B:method0");
    }

    public void method1() {
        System.out.println("B:method1");
    }
}

a.method0()结果
没有Class B中的方法

注
我们可以看到，打印出来的是Class B的方法，但是用a.去调用方法的时候，没有B中的method1的方法。
为什么？
首先，我们实例化的是一个B的对象，但是我们将其强行转成了A(也就是通过父类实例化子类)，为什么我们可以调B中的method0，因为我们写的方法覆盖了父类原有的方法，所以打印的是B。
意义
当我们需要多个同父类的对象调用父类的某一个方法是，可以通过向上转型统一方法和参数。

应用

class UpCast {
    public static void main(String[] args) {
        A a =  new B();
        a.method0();

        func(new B());
        func(new C());

    }

    static void func(A a) {
        a.method0();
    }
}

class A {
    public void method0() {
        System.out.println("A::method0");
    }

    public void method() {
        System.out.println("A:method");
    }
}

class B extends A {

    public void method0() {
        System.out.println("B:method0");
    }

    public void method1() {
        System.out.println("B:method1");
    }
}

class C extends B {

    public void method0() {
        System.out.println("C:method0");
    }

}

如果把C中的method0去掉，那么就会打印B中的method0，如果把B中的method0去掉，那么打印的就是A中默认的方法method0。这就是向上转型的好处。调用统一的方法。

---

向下转型

为了保证向下转型的顺利完成,在java中提供了一个关键字:instanceof,通过instanceof可以判断某对象是否是某类的实例,如果是则返回true,否则为false,instanceof使用如下:

A a = new B();                 //向上转型 (B类是A的子类)

a instanceof A;                //返回true.
a instanceof B;                //返回true
a instanceof C;                //返回false

class DownCast {

    public static void main(String[] args) {
        func(new A());
        func(new B());
        func(new C());
    }

    static void func(A a) {
        a.method0();
        if (a instanceof B) {
            B b = (B) a;
            b.method();
        } else if (a instanceof C) {
            C c = (C) a;
            a.method();
        }
    }
}

class A {
    public void method0() {
        System.out.println("A::method0");
    }

    public void method() {
        System.out.println("A:method");
    }
}

class B extends A {

    public void method0() {
        System.out.println("B:method0");
    }

    public void method1() {
        System.out.println("B:method1");
    }
}

class C extends B {

    public void method0() {
        System.out.println("C:method0");
    }

}

结果

解释：
B向上转型成A之后，可以通过向下转型调用B自身的方法。
注：举个例子，将B对象转成A对象之后（向上转型），同时经过向下转型之后，再次转成B对象，可以调用A对象的方法和自身的方法