连载：面向对象葵花宝典：思想、技巧与实践（13） - “多态” 详解

在此要向将polymorphism翻译成“多态”的人致敬！

因为多态的英文实在是太难理解了，而中文翻译得又如此形象如此贴切。

 

从字面意思上就可以看出，多态就是“多种形态”的意思。但仔细探究一下：“多种形态”其实还是没法很好的理解，不同的人也还是会有不同的理解。

 

动画片看得多的同学可能会以为：多种形态，就是很多种变身啦 ：），就像孙悟空72变一样，一会儿可以变成房子，一会儿可以变成牛魔王。。。。。。

 

擅长盛装打扮的美女可能会以为：多种形态，其实就是换不同的衣服嘛，你看我一会文艺小清新打扮，一会儿高贵典雅的贵妇人装束，一会儿小鸟依人的淑女形象。。。。。。

 

学院派技术宅男可能会以为：多种形态，其实就是多种状态啦，比如说TCP协议栈有XX种状态，线程有XX种状态。。。。。。

 

还可能有很多其它各种各样的理解，但在面向对象领域，这些理解都不正确，多态不是变身、不是换装、不是状态变化，而是“多胎”！！

 

你可能会很惊讶，以为这里是打字打错了，怎么可能是“多胎”呢？“多胎”又是什么意思呢？

 

多胎在这里也是一个形象的说法，在面向对象领域，多态的真正含义是：使用指向父类的指针或者引用，能够调用子类的对象。

 

我们以java程序为例：

Animal.java

[java]  view plain copy

1. package com.oo.base.polymorphism;  
2.   
3. /** 
4.  * 这是父类 
5.  * 
6.  */  
7. public abstract class Animal {  
8.     abstract String talk();  
9. }  

Dog.java

[java]  view plain copy

1. package com.oo.base.polymorphism;  
2.   
3. /** 
4.  * 子类：狗 
5.  * 
6.  */  
7. public class Dog extends Animal {  
8.   
9.     public Dog() {  
10.           
11.     }  
12.   
13.     @Override  
14.     String talk() {  
15.           
16.         return "Dog......wang wang";  
17.     }  
18.   
19. }  

Pig.java

[java]  view plain copy

1. package com.oo.base.polymorphism;  
2.   
3. /** 
4.  * 子类：猪 
5.  * 
6.  */  
7. public class Pig extends Animal {  
8.   
9.     public Pig() {  
10.           
11.     }  
12.   
13.     @Override  
14.     String talk() {  
15.           
16.         return "Pig......ao ao";  
17.     }  
18.   
19. }  

Cat.java

[java]  view plain copy

1. package com.oo.base.polymorphism;  
2.   
3. /** 
4.  * 子类：猫 
5.  * 
6.  */  
7. public class Cat extends Animal {  
8.   
9.     public Cat() {  
10.           
11.     }  
12.   
13.     @Override  
14.     String talk() {  
15.           
16.         return "Cat......miao miao";  
17.     }  
18.   
19. }  

Test.java

[java]  view plain copy

1. package com.oo.base.polymorphism;  
2.   
3. public class Test1 {  
4.       
5.     /** 
6.      *  
7.      * @param a Animal  这个参数就是“多态”的具体表现形式 
8.      */  
9.     public static void write(Animal a) {  
10.         //在调用a.talk()的时候, 函数并不知道a究竟是Pig，Dog，还是Cat，只知道是一个Animal  
11.         System.out.println(a.talk());   
12.     }  
13.       
14.     public static void main(String[] args) {  
15.         //在调用write函数的时候，可以传入Cat/Dog/Pig对象，并且输出也不一样  
16.         write(new Cat()); //传入Cat，输出"Cat......miao miao"  
17.         write(new Dog()); //传入Dog，输出"Dog......wang wang"  
18.         write(new Pig()); //传入Pig，输出"Pig......ao ao"  
19.     }  
20. }  

从上面的样例可以看出，Pig、Dog、Cat是三个Animal的子类，在函数调用的时候，参数类型指定为Animal，但具体传入的参数值可以是Animal的子类Pig、Dog、Cat，也就是说：指定为Animal类型的参数，可以为Pig，也可以为Dog，也可以为Cat，总共有3中不同的形态。

 

多态的特性在面向对象编程的领域中具有十分重要的作用。多态屏蔽了子类对象的差异，使得调用者可以写出通用性的代码，而无需针对每个子类都需要写不同的代码。

例如，如上的样例，如果没有多态，Test的write函数就必须这么写了：

[java]  view plain copy

1. package com.oo.base.polymorphism;  
2.   
3. /** 
4.  * 不支持多态的Test实现 
5.  * 
6.  */  
7. public class Test2 {  
8.       
9.     /** 
10.      * 如果不支持多态，每个write函数都需要和具体的子类对应， 
11.      * writeCat对应Cat子类 
12.      * @param a 
13.      */  
14.     public static void writeCat(Cat a) {  
15.         System.out.println(a.talk());   
16.     }  
17.       
18.     /** 
19.      * 如果不支持多态，每个write函数都需要和具体的子类对应， 
20.      * writeDog对应Dog子类 
21.      * @param a 
22.      */  
23.     public static void writeDog(Dog a) {  
24.         System.out.println(a.talk());   
25.     }  
26.       
27.     /** 
28.      * 如果不支持多态，每个write函数都需要和具体的子类对应， 
29.      * writePig对应Pig子类 
30.      * @param a 
31.      */  
32.     public static void writePig(Pig a) {  
33.         System.out.println(a.talk());   
34.     }  
35.       
36.     public static void main(String[] args) {  
37.           
38.         //需要针对每个子类调用不同的函数  
39.         writeCat(new Cat()); //传入Cat，输出"Cat......miao miao"  
40.         writeDog(new Dog()); //传入Dog，输出"Dog......wang wang"  
41.         writePig(new Pig()); //传入Pig，输出"Pig......ao ao"  
42.     }  
43. }  

上面的代码与Test1的代码对比，很明显Test1的要清晰和简洁很多，要少写很多代码。

 

除了能够让代码清晰简洁外，多态还有一个更加重要的作用：

当增加新的子类时，调用者的代码无需变动就能适用新的子类。

以Test1为例，假设我们增加一个Cock的Animal子类，Test1的代码无需任何改变就可以支持Cock类，而Test2则需要增加一个writeCock的函数。