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;
}
}