JAVA 面向对象之 多态

本页面更新日期: 2016年07月30日

前言

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 = "孙子兵法";    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();        //将输出 "孙子兵法"        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();    }}

上面程序的 main() 方法中显式创建了 三个 引用变量.
对于前面两个引用变量 bc 和 sc , 它们编译时类型和运行时类型完全相同.
因此调用它们的成员变量和方法非常正确, 完全没有任何问题.
但第三个引用变量 ploymophicBc 比较特殊.
它的编译时类型是 BaseClass , 而运行时类型是 SubClass
当调用该引用变量的 test() 方法 (BaseClass 类中定义了该方法, 子类 SubClass 覆盖了父类的该方法) 时.
实际执行的是 SubClass 类中覆盖后的 test() 方法, 这就可能出现多态了.

因为子类其实是一种特殊的父类.
因此 Java允许把一个子类对象直接赋给一个父类引用变量.
无须任何类型转换, 或者被称为向上转型(upcasting).
向上转型由系统自动完成.

当把一个子类对象直接赋给父类引用变量时.
例如上面的 BaseClass ploymophicBc = new SubClass();
这个 ploymophicBc 引用变量的编译时类型是 BaseClass
而运行时类型是 SubClass .
当运行时调用该引用变量的方法时, 其方法行为总是表现出子类方法的行为特征.
而不是父类方法的行为特征, 这就可能出现:

• 相同类型的变量 / 调用 同一个方法时呈现出多种不同的行为特征, 这就是多态.

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

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

注意:

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

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

那么问题来了, 多态存在的意义是什么? 点我查看

引用变量的强制类型转换

编写 Java 程序时, 引用变量只能调用它编译时类型的方法.
而不能调用它运行时类型的方法.
即使它实际所引用的对象确实包含该方法.
如果需要让这个引用变量调用它运行时类型的方法, 则必需把它强制类型转换成运行时类型.
强制类型转换需要借助于类型转换运算符.

类型转换运算符是小括号.
类型转换运算符的用法是: (type)variable
这种用法可以将 variable 变量转换成一个 type 类型的变量.
前面在介绍基本类型的强制类型转换时, 已经看到了使用这种类型转换运算符的用法.
类型转换运算符可以将一个基本类型变量转换成另一个类型.

除此之外,这个类型转换运算符还可以将一个引用类型变量转换成其子类类型.
这种强制类型转换不是万能的, 当进行强制类型转换时需要注意:

• 基本类型之间的转换只能在数值类型之间进行. 这里所说的数值类型包括 整数型 / 字符型 / 浮点型 . 但数值类型和布尔类型之间不能进行类型转换.
• 引用类型之间的转换只能在具有继承关系的两个类型之间进行. 如果时两个没有任何继承关系的类型, 则无法进行类型转换, 否则编译时就会出现错误. 如果试图把一个父类实例转换成子类类型, 则这个对象必需实际上是子类实例才行(即编译时类型为父类类型, 而运行时类型是子类类型), 否则将在运行时引发 ClassCastException 异常.

下面是进行强制类型转换的示范程序.
详细说明了哪些情况可以进行类型转换, 哪些情况不能.

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