＋设为首页 ＋添加到收藏夹
【程序编程相关:能用Firefox替代Internet 】
thinking in java简明教程 - 多形性 【推荐阅读:利用代码发送的动态退化或同步化接口封装】“多形性”（polymorphism）从另一个角度将接口从具体的实施细节中分离出来,亦即实现了“是什么”与“怎样做”两个模块的分离.利用多形性的概念,代码的组织以及可读性均能获得改善.此外,还能创建“易于扩展”的程序.无论在项目的创建过程中,还是在需要加入新特性的时候,它们都可以方便地“成长”. 【扩展信息:[票据打印]使用扫描仪加快可视化编程工具】
“对于面向对象的程序设计语言,多型性是第三种最基本的特征（前两种是数据抽象与继承.” 通过合并各种特征与行为,封装技术可创建出新的数据类型.通过对具体实施细节的隐藏,可将接口与实施细节分离,使所有细节成为“private”（私有）.这种组织方式使那些有程序化编程背景人感觉颇为舒适.但多形性却涉及对“类型”的分解.通过上一章的学习,大家已知道通过继承可将一个对象当作它自己的类型或者它自己的基础类型对待.这种能力是十分重要的,因为多个类型（从相同的基础类型中衍生出来）可被当作同一种类型对待.而且只需一段代码,即可对所有不同的类型进行同样的处理.利用具有多形性的方法调用,一种类型可将自己与另一种相似的类型区分开,只要它们都是从相同的基础类型中衍生出来的.这种区分是通过各种方法在行为上的差异实现的,可通过基础类实现对那些方法的调用.在这一章中,大家要由浅入深地学习有关多形性的问题（也叫作动态绑定.推迟绑定或者运行期绑定）.同时举一些简单的例子,其中所有无关的部分都已剥除,只保留与多形性有关的代码.7.1 上溯造型
在第6章,大家已知道可将一个对象作为它自己的类型使用,或者作为它的基础类型的一个对象使用.取得一个对象句柄,并将其作为基础类型句柄使用的行为就叫作“上溯造型”——因为继承树的画法是基础类位于最上方.但这样做也会遇到一个问题,如下例所示（若执行这个程序遇到麻烦,请参考第3章的3.1.2小节“赋值”）: //: music.java // inheritance & upcastingpackage c07;class note {
private int value;private note(int val) { value = val; }public static final notemiddlec = new note(0), csharp = new note(1),cflat = new note(2);} // etc.class instrument {
public void play(note n) {system.out.println("instrument.play()");}}// wind objects are instruments
// because they have the same interface:class wind extends instrument {// redefine interface method:public void play(note n) {system.out.println("wind.play()");}}public class music {
public static void tune(instrument i) {// ...i.play(note.middlec);}public static void main(string[] args) {wind flute = new wind();tune(flute); // upcasting}} ///:~其中,方法music.tune()接收一个instrument句柄,同时也接收从instrument衍生出来的所有东西.当一个wind句柄传递给tune()的时候,就会出现这种情况.此时没有造型的必要.这样做是可以接受的;instrument里的接口必须存在于wind中,因为wind是从instrument里继承得到的.从wind向instrument的上溯造型可能“缩小”那个接口,但不可能把它变得比instrument的完整接口还要小.
7.1.1 为什么要上溯造型
这个程序看起来也许显得有些奇怪.为什么所有人都应该有意忘记一个对象的类型呢?进行上溯造型时,就可能产生这方面的疑惑.而且如果让tune()简单地取得一个wind句柄,将其作为自己的自变量使用,似乎会更加简单.直观得多.但要注意:假如那样做,就需为系统内instrument的每种类型写一个全新的tune().假设按照前面的推论,加入stringed（弦乐）与brass（铜管）这两种instrument（乐器）://: music2.java
// overloading instead of upcastingclass note2 {
private int value;private note2(int val) { value = val; }public static final note2middlec = new note2(0), csharp = new note2(1),cflat = new note2(2);} // etc.class instrument2 {
public void play(note2 n) {system.out.println("instrument2.play()");}}class wind2 extends instrument2 {
public void play(note2 n) {system.out.println("wind2.play()");}}class stringed2 extends instrument2 {
public void play(note2 n) {system.out.println("stringed2.play()");}}class brass2 extends instrument2 {
public void play(note2 n) {system.out.println("brass2.play()");}}public class music2 {
public static void tune(wind2 i) {i.play(note2.middlec);}public static void tune(stringed2 i) {i.play(note2.middlec);}public static void tune(brass2 i) {i.play(note2.middlec);}public static void main(string[] args) {wind2 flute = new wind2();stringed2 violin = new stringed2();brass2 frenchhorn = new brass2();tune(flute); // no upcastingtune(violin);tune(frenchhorn);}} ///:~这样做当然行得通,但却存在一个极大的弊端:必须为每种新增的instrument2类编写与类紧密相关的方法.这意味着第一次就要求多得多的编程量.以后,假如想添加一个象tune()那样的新方法或者为instrument添加一个新类型,仍然需要进行大量编码工作.此外,即使忘记对自己的某个方法进行过载设置,编译器也不会提示任何错误.这样一来,类型的整个操作过程就显得极难管理,有失控的危险.
但假如只写一个方法,将基础类作为自变量或参数使用,而不是使用那些特定的衍生类,岂不是会简单得多?也就是说,如果我们能不顾衍生类,只让自己的代码与基础类打交道,那么省下的工作量将是难以估计的.这正是“多形性”大显身手的地方.然而,大多数程序员（特别是有程序化编程背景的）对于多形性的工作原理仍然显得有些生疏.7.2 深入理解
对于music.java的困难性,可通过运行程序加以体会.输出是wind.play().这当然是我们希望的输出,但它看起来似乎并不愿按我们的希望行事.请观察一下tune()方法:public static void tune(instrument i) {
// ...i.play(note.middlec);}它接收instrument句柄.所以在这种情况下,编译器怎样才能知道instrument句柄指向的是一个wind,而不是一个brass或stringed呢?编译器无从得知.为了深入了理解这个问题,我们有必要探讨一下“绑定”这个主题.
7.2.1 方法调用的绑定
将一个方法调用同一个方法主体连接到一起就称为“绑定”（binding）.若在程序运行以前执行绑定（由编译器与链接程序,如果有的话）,就叫作“早期绑定”.大家以前或许从未听说过这个术语,因为它在任何程序化语言里都是不可能的.c编译器只有一种方法调用,那就是“早期绑定”.上述程序最令人迷惑不解的地方全与早期绑定有关,因为在只有一个instrument句柄的前提下,编译器不知道具体该调用哪个方法.解决的方法就是“后期绑定”,它意味着绑定在运行期间进行,以对象的类型为基础.后期绑定也叫作“动态绑定”或“运行期绑定”.若一种语言实现了后期绑定,同时必须提供一些机制,可在运行期间判断对象的类型,并分别调用适当的方法.也就是说,编译器此时依然不知道对象的类型,但方法调用机制能自己去调查,找到正确的方法主体.不同的语言对后期绑定的实现方法是有所区别的.但我们至少可以这样认为:它们都要在对象中安插某些特殊类型的信息.java中绑定的所有方法都采用后期绑定技术,除非一个方法已被声明成final.这意味着我们通常不必决定是否应进行后期绑定——它是自动发生的.为什么要把一个方法声明成final呢?正如上一章指出的那样,它能防止其他人覆盖那个方法.但也许更重要的一点是,它可有效地“关闭”动态绑定,或者告诉编译器不需要进行动态绑定.这样一来,编译器就可为final方法调用生成效率更高的代码.7.2.2 产生正确的行为
知道java里绑定的所有方法都通过后期绑定具有多形性以后,就可以相应地编写自己的代码,令其与基础类沟通.此时,所有的衍生类都保证能用相同的代码正常地工作.或者换用另一种方法,我们可以“将一条消息发给一个对象,让对象自行判断要做什么事情.”在面向对象的程序设计中,有一个经典的“形状”例子.由于它很容易用可视化的形式表现出来,所以经常都用它说明问题.但很不幸的是,它可能误导初学者认为oop只是为图形化编程设计的,这种认识当然是错误的.形状例子有一个基础类,名为shape;另外还有大量衍生类型:circle（圆形）,square（方形）,triangle（三角形）等等.大家之所以喜欢这个例子,因为很容易理解“圆属于形状的一种类型”等概念.下面这幅继承图向我们展示了它们的关系:上溯造型可用下面这个语句简单地表现出来:shape s = new circle();
在这里,我们创建了circle对象,并将结果句柄立即赋给一个shape.这表面看起来似乎属于错误操作（将一种类型分配给另一个）,但实际是完全可行的——因为按照继承关系,circle属于shape的一种.因此编译器认可上述语句,不会向我们提示一条出错消息.
当我们调用其中一个基础类方法时（已在衍生类里覆盖）:s.draw();同样地,大家也许认为会调用shape的draw(),因为这毕竟是一个shape句柄.那么编译器怎样才能知道该做其他任何事情呢?但此时实际调用的是circle.draw(),因为后期绑定已经介入（多形性）.下面这个例子从一个稍微不同的角度说明了问题://: shapes.java
// polymorphism in javaclass shape {
void draw() {}void erase() {} }class circle extends shape {
void draw() { system.out.println("circle.draw()"); }void erase() { system.out.println("circle.erase()"); }}class square extends shape {
void draw() { system.out.println("square.draw()"); }void erase() { system.out.println("square.erase()"); }}class triangle extends shape {
void draw() { system.out.println("triangle.draw()"); }void erase() { system.out.println("triangle.erase()");}}public class shapes {
public static shape randshape() {switch((int)(math.random() * 3)) {default: // to quiet the compilercase 0: return new circle();case 1: return new square();case 2: return new triangle();}}public static void main(string[] args) {shape[] s = new shape[9];// fill up the array with shapes:for(int i = 0; i < s.length; i++)s[i] = randshape();// make polymorphic method calls:for(int i = 0; i < s.length; i++)s[i].draw();}} ///:~针对从shape衍生出来的所有东西,shape建立了一个通用接口——也就是说,所有（几何）形状都可以描绘与删除.衍生类覆盖了这些定义,为每种特殊类型的几何形状都提供了独一无二的行为.
在主类shapes里,包含了一个static方法,名为randshape().它的作用是在每次调用它时为某个随机选择的shape对象生成一个句柄.请注意上溯造型是在每个return语句里发生的.这个语句取得指向一个circle,square或者triangle的句柄,并将其作为返回类型shape发给方法.所以无论什么时候调用这个方法,就绝对没机会了解它的具体类型到底是什么,因为肯定会获得一个单纯的shape句柄.main()包含了shape句柄的一个数组,其中的数据通过对randshape()的调用填入.在这个时候,我们知道自己拥有shape,但不知除此之外任何具体的情况（编译器同样不知）.然而,当我们在这个数组里步进,并为每个元素调用draw()的时候,与各类型有关的正确行为会魔术般地发生,就象下面这个输出示例展示的那样:circle.draw()
triangle.draw()circle.draw()circle.draw()circle.draw()square.draw()triangle.draw()square.draw()square.draw()当然,由于几何形状是每次随机选择的,所以每次运行都可能有不同的结果.之所以要突出形状的随机选择,是为了让大家深刻体会这一点:为了在编译的时候发出正确的调用,编译器毋需获得任何特殊的情报.对draw()的所有调用都是通过动态绑定进行的.
7.2.3 扩展性
现在,让我们仍然返回乐器（instrument）示例.由于存在多形性,所以可根据自己的需要向系统里加入任意多的新类型,同时毋需更改true()方法.在一个设计良好的oop程序中,我们的大多数或者所有方法都会遵从tune()的模型,而且只与基础类接口通信.我们说这样的程序具有“扩展性”,因为可以从通用的基础类继承新的数据类型,从而新添一些功能.如果是为了适应新类的要求,那么对基础类接口进行操纵的方法根本不需要改变,对于乐器例子,假设我们在基础类里加入更多的方法,以及一系列新类,那么会出现什么情况呢?下面是示意图:所有这些新类都能与老类——tune()默契地工作,毋需对tune()作任何调整.即使tune()位于一个独立的文件里,而将新方法添加到instrument的接口,tune()也能正确地工作,不需要重新编译.下面这个程序是对上述示意图的具体实现:... 下一页