1、概述

1.1 场景

转型，是 Java 多态的特性之一（继承、重写、转型），初学时，总会产生些疑问，比如：转型是用来干啥的呢？啥时候用转型呢？本片文章，就是来 归纳总结 - 转型的应用及意义。

1.2 结论

向上转型： 子类转父类，属于 自动转换 // Father s = new Son();
- 意义： 实现 "参数统一"，方便程序设计。
向下转型： 父类转子类，需要 强制转换 // Son s = (Son) f;
- 意义： 方便调用子类 "独有方法"。

1.3 思维导图

在这里插入图片描述

2、向上转型

2.1 使用方法

向上转型时，父类对象只能调用 父类方法或者子类覆盖后的方法，而子类单独的方法是无法调用的
B extends A

class A {
    public void print() {
        System.out.println("A 中的 print()");
    }
}

class B extends A {

    @Override
    public void print() {
        System.out.println("B 中的 print()");
    }

    public void fun() {
        System.out.println("B 中的 独有方法");
    }
}


public class Test {

    public static void main(String[] args) {
        A b = new B();
        // b.fun(); 报错
        b.print(); // 输出：B 中的 print()
    }
}

2.2 意义

当我们需要多个同父的对象调用某个方法时，通过向上转换后,则可以确定参数的统一，方便程序设计。
C extends B extends A

class A {
    public void print() {
        System.out.println("A 中的 print()");
    }
}

class B extends A {

    @Override
    public void print() {
        System.out.println("B 中的 print()");
    }

    public void fun() {
        System.out.println("B 中的 独有方法");
    }
}

class C extends B {

    @Override
    public void print() {
        System.out.println("C 中的 print()");
    }
}


public class Test {

    public static void method(A a) { // 参数统一（向上转型的意义！）
        a.print();
    }

    public static void main(String[] args) {
        C c = new C(); // 等价于 A c = new C(); 自动转换 - 向上转型
        B b = new B(); // 等价于 A b = new B();

        method(c); // C 中的 print()
        method(b); // B 中的 print()
    }
}

3、向下转型

3.1 使用方法

通过父类强制转换为子类，从而来调用子类 独有的方法
为了向下转型顺利完成， Java 中提供了一个关键字：instanceof （来判断某对象是否是某类的实例）

instanceof 演示：

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

a instanceof A; // true
a instanceof B; // true
a instanceof C; // false

案例演示：

class A {
    public void print() {
        System.out.println("A 中的 print()");
    }
}

class B extends A {

    @Override
    public void print() {
        System.out.println("B 中的 print()");
    }

    public void funB() {
        System.out.println("B 中的 独有方法");
    }
}

class C extends B {

    @Override
    public void print() {
        System.out.println("C 中的 print()");
    }

    public void funC() {
        System.out.println("C 中的 独有方法");
    }
}


public class Test {

    public static void method(A a) { // 参数统一

        if (a instanceof C) { // 注意判断顺序哦！
            C c = (C) a;
            c.funC();
        } else if (a instanceof B) {
            B b = (B) a;
            b.funB();
        } else {
            a.print(); // 肯定都是 A 的实例，因为：B、C 都是 A 的子类
        }
    }

    public static void main(String[] args) {
        C c = new C(); // 等价于 A c = new C(); 自动转换 - 向上转型
        B b = new B(); // 等价于 A b = new B();

        method(c); // C 中的 独有方法
        method(b); // B 中的 独有方法
    }
}