Java面向对象系列[v1.0.0][多态详解]

Java引用变量有两个类型，一个是编译时类型，一个是运行时类型，编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就可能出现所谓的多态【Polymorphism】

多态性

class BaseClass
{
    public int book = 6;
    public void base()
    {
        System.out.println("父类的普通方法");
    }
    public void test()
    {
        System.out.println("父类的被覆盖的方法");
    }
}
public class SubClass extends BaseClass
{
    //重新定义一个book实例变量隐藏父类的book实例变量
    public String book = "轻量级Java EE企业应用实战";
    public void test()
    {
        System.out.println("子类的覆盖父类的方法");
    }
    public void sub()
    {
        System.out.println("子类的普通方法");
    }
    public static void main(String[] args)
    {
        // 下面编译时类型和运行时类型完全一样，因此不存在多态
        BaseClass bc = new BaseClass();
        // 输出 6
        System.out.println(bc.book);
        // 下面两次调用将执行BaseClass的方法
        bc.base();
        bc.test();
        // 下面编译时类型和运行时类型完全一样，因此不存在多态
        SubClass sc = new SubClass();
        // 输出"轻量级Java EE企业应用实战"
        System.out.println(sc.book);
        // 下面调用将执行从父类继承到的base()方法
        sc.base();
        // 下面调用将执行从当前类的test()方法
        sc.test();
        // 下面编译时类型和运行时类型不一样，多态发生
        BaseClass ploymophicBc = new SubClass();
        // 输出6 —— 表明访问的是父类对象的实例变量
        System.out.println(ploymophicBc.book);
        // 下面调用将执行从父类继承到的base()方法
        ploymophicBc.base();
        // 下面调用将执行从当前类的test()方法
        ploymophicBc.test();
        // 因为ploymophicBc的编译类型是BaseClass，
        // BaseClass类没有提供sub方法,所以下面代码编译时会出现错误。
        // ploymophicBc.sub();
    }
}

• 因为子类是一种特殊的父类，因此Java允许把子类对象直接赋给一个父类引用变量，无需任何类型转换，或者被称为向上转型（upcasting），向上转型由系统自动完成。

• 当把一个子类对象直接赋给父类引用变量时， BaseClass ploymophicBc = new SubClass();这个ploymophicBc引用变量的编译时类型是BaseClass，而运行时类型是SubClass，当运行时调用该引用变量的方法时，其方法行为总是表现出子类方法的行为特征，而不是父类方法的行为特征，这就可能出现：相同类型的变量、调用同一个方法时呈现出多种不同的行为特征，这就是多态

• main()方法中注释掉了ploymophicBc.sub();这行代码会在编译时引发错误，虽然polymophicBc引用变量实际上确实包含sub()，但因为它的编译类型为BaseClass，因此编译时无法调用 sub()方法

• 与方法不同的是，对象的实例变量则不具备多态性，比如上面的ploymophicBc引用变量，程序中输出它的book实例变量时，并不会输出SubClass类里定义的实例变量，而是输出BaseClass类的实例变量

• 引用变量在编译阶段只能调用其编译时类型所具有的方法，但运行时则执行它运行时类型所具有的方法，因此编写Java代码时，引用变量只能调用声明该变量时所用类里包含的方法。例如Object p = new Persion();代码定义一个变量p，则这个p只能调用Object类的方法，而不能调用Person类里定义的方法

• 通过引用变量来访问其包含的实例变量时，系统总是试图访问它编译时类型所定义的成员变量，而不是它运行时类型所定义的成员变量

引用变量的强制类型转换

编写java程序时，引用变量只能调用它编译时类型的方法，而不能调用它运行时类型的方法，即使它实际所引用的对象确实包含该方法，如果想让这个引用类型调用运行时类型的方法，则必须把它强制类型转换成运行时类型，强制类型转换需要借助于类型转换运算符。
类型转换运算符是小括号，用法是(type)variable,这种用法可以将variable变量转换成一个type类型的变量，类型转换运算符可以将一个基本类型变量转换成另一个类型，还可以将一个引用类型变量转换成其子类类型。
进行强制类型转换时，应注意：

• 基本类型之间的转换只能在数值类型之间进行，包括整数型、字符型和浮点型，数值类型和布尔类型之间不能进行转换
• 引用类型之间的转换只能在具有继承关系的两个类型之间进行，如果是两个没有任何继承关系的类型则无法进行类型转换
• 如果试图将一个父类实例转换成子类类型，则这个对象必须实际上是子类实例才行（即编译时类型为父类类型，而运行时类型是子类类型），否则将报ClassCaseException

public class ConversionTest
{
    public static void main(String[] args)
    {
        var d = 13.4;
        var l = (long) d;
        System.out.println(l);
        var in = 5;
        // 试图把一个数值类型的变量转换为boolean类型，下面代码编译出错
        // 编译时候会提示: 不可转换的类型
        // var b = (boolean) in;
        Object obj = "Hello";
        // obj变量的编译类型为Object，Object与String存在继承关系，可以强制类型转换
        // 而且obj变量实际上类型是String类型，所以运行时也可通过
        var objStr = (String) obj;
        System.out.println(objStr);
        // 定义一个objPri变量，编译类型为Object，实际类型为Integer
        Object objPri = Integer.valueOf(5);
        // objPri变量的编译时类型为Object，objPri的运行时类型为Integer，Object与Integer存在继承关系
        // 可以强制类型转换，而objPri变量实际上类型是Integer类型，
        // 所以下面代码运行时引发ClassCastException异常
        // var str = (String) objPri;
    }
}

考虑到类型强制转换很可能会遇到异常，因此进行类型转换之前应先通过instanceof进行判断是否能够成功进行相应的转换，例如如下代码进行强制转换会报异常：

Object objPri = Integer.valueOf(5);
var str = (String) objPri；

为了让程序更健壮，应改为：

if(objPri instanceof String)
{
    String str = (String)objPri;
}

• 当把子类对象赋给父类引用变量时，被称为向上转型（upcasting），这种转型总是可以成功的，这种转型表明这个引用变量的编译时类型是父类，但实际执行它的方法时，依然表现出子类对象的行为方式。
• 反过来把父类对象赋给子类引用变量引用变量时，就需要进行强制类型转换，而且还可能在运行时产生ClassCaseException

instanceof运算符

• instanceof运算符的前一个操作数通常是一个引用类型变量，后一个操作数通常是一个类（也可以是个接口），它用于判断前边的对象是否是后边的类、或者其子类，实现类的实例，如果是返回True如果不是返回False
• 在使用instanceof运算符时，前边操作数的编译时类型要么与后边的类相同，要么与后边的类具有父子继承关系，否则编译会出错

public class InstanceofTest
{
    public static void main(String[] args)
    {
        // 声明hello时使用Object类，则hello的编译类型是Object，
        // Object是所有类的父类, 但hello变量的实际类型是String
        Object hello = "Hello";
        // String与Object类存在继承关系，可以进行instanceof运算。返回true。
        System.out.println("字符串是否是Object类的实例："
            + (hello instanceof Object));
        System.out.println("字符串是否是String类的实例："
            + (hello instanceof String)); // 返回true。
        // Math与Object类存在继承关系，可以进行instanceof运算。返回false。
        System.out.println("字符串是否是Math类的实例："
            + (hello instanceof Math));
        // String实现了Comparable接口，所以返回true。
        System.out.println("字符串是否是Comparable接口的实例："
            + (hello instanceof Comparable));
        var a = "Hello";
        // String类与Math类没有继承关系，所以下面代码编译无法通过
        // System.out.println("字符串是否是Math类的实例："
        // + (a instanceof Math));
    }
}

instanceof和type是java提供的两个相关的运算符，先用instanceof进行判断一个对象是否可以强制类型转换，然后再用type运算符进行实际转换