深入浅出话多态（下）――牛刀小试

深入浅出话多态（下）――牛刀小试
小序

       英格兰走了……巴西的表演还没有开场。闲着也是闲着，我把下篇写出来。

 

正文

一．多态的现实意义
       如果一个编程元素没有可以应用在软件工程中的现实意义，那将是一件不可容忍的事情。同理，如果你不了解一个编程元素的现实意义、不知道在编程时应该怎么用，就不能说自己懂得了这个编程元素。

       我的编程经验实在不多，就我个人感觉，多态最大的现实意义在于“代码的简化”。

       多态为什么能简化代码捏？

       先让我们用一句话概括多态的实现：首先要一个人父类，在这个父类的成员中，有一个virtual的（可以被子类重写的）方法。然后，有N多子类继承了这个父类，并且用override重写了父类的那个virtual方法――此时已经形成了一个扇形的多态继承图。当然，如果用作“父类”的是一个接口，那么在子类中就不是“重写”方法，而是“实现”方法了。

       一旦这个“继承扇”形成了，我们应该意识到――无论是父类还是子类，他们都有一个同名的方法，而且此同名方法在各个子类中是“个性化”的――它重写了父类的方法、并且子类与子类之间的这个同名方法也各不相同。

       在程序的编写期，程序员总要预期用户可能进行的各种操作――比如对“继承扇”中每个子类的操作。程序编译完成、成为可执行文件并交付用户后，程序员就不能再控制程序了，这时候程序只能听从用户的摆布。假设没有多态，那么为了让用户在调用每个子类的时候程序都能有正确的响应，程序员不得不为每个子类在内存中创建一个实例――这样一来，程序复杂度增加的同时，性能也下降了。还好，这只是个假设……

       OK，让我们还是来拿代码说事儿吧。下面给出两段代码，对比显示了多态的巨大优越性。

 

代码1：非多态排比代码

 

//                          水之真谛                                     //
//            [url]http://blog.csdn.net/FantasiaX[/url]               //
//                   上善若水，润物无声                             //

using System;
using System.Collections.Generic;
using System.Text;

namespace Sample
{
      class OptimusPrime                    //博派老大擎天柱
      {
           public void Transform()
           {
                 Console.WriteLine("Transform to a TRUCK...");
           }
      }

      class Megatron                          //狂派老大威震天
      {
           public void Transform()
           {
                 Console.WriteLine("Transform to a GUN...");
           }
      }

      class Bumblebee                        //大黄蜂
      {
           public void Transform()
           {
                 Console.WriteLine("Transform to a CAR...");
           }
      }

      class Starscream                       //红蜘蛛
      {
           public void Transform()
           {
                 Console.WriteLine("Transform to a FIGHTER...");
           }
      }

      class Program                           //主程序类
      {
           static void Main(string[] args)
           {
                 string number = string.Empty;
                
                 //为每个类准备一个实例
                 OptimusPrime transformer1 = new OptimusPrime();
                 Megatron transformer2 = new Megatron();
                 Bumblebee transformer3 = new Bumblebee();
                 Starscream transformer4 = new Starscream();

                 while (true)                   //无限循环
                 {
                      Console.WriteLine("Please input 1/2/3/4 to choose a transformer...");
                      number = Console.ReadLine();

                      switch (number)      //根据用户选择，作出响应
                      {
                            case "1":
                                  transformer1.Transform();
                                  break;

                            case "2":
                                  transformer2.Transform();
                                  break;

                            case "3":
                                  transformer3.Transform();
                                  break;

                            case "4":
                                  transformer4.Transform();
                                  break;

                            default:
                                  Console.WriteLine("Do you want a TRACTOR ??");
                                  break;
                      }
                 }
           }
      }
}
代码分析：

1.        一上来是4个独立的类（相信这4位人物大家都不陌生吧……），这4个类有一个同名方法：Transform()。虽然同名，但各自的实现却是“个性化”的、完全不同的――我们这里只用输出不同的字符串来表示，但你想啊――同样是有胳膊有腿的一个大家伙，变成汽车的方法跟变成飞机、变成枪怎么可能一样呢？

2.        进入主程序后，先是为每个类实例化一个对象出来，以备用户自由调用。这么做是很占内存的，如果为了优化程序，对每个类的实例化是可以挪到switch的每个case分支里的。

3.        一个无限循环，可以反复输入数字……

4.        switch…case…根据用户的需求来调用合适的Transformer的Transform方法。

 

 

代码2：使用多态，简化代码

 

//                          水之真谛                                     //
//            [url]http://blog.csdn.net/FantasiaX[/url]               //
//                   上善若水，润物无声                             //

using System;
using System.Collections.Generic;
using System.Text;

namespace Sample
{
      class Transformer                                      //基类
      {
           public virtual void Transform()
           {
                 Console.WriteLine("Transform to a ??? ???...");
           }
      }

      class OptimusPrime : Transformer            //博派老大擎天柱
      {
           public override void Transform()
           {
                 Console.WriteLine("Transform to a TRUCK...");
           }
      }

      class Megatron : Transformer                       //狂派老大威震天
      {
           public override void Transform()
           {
                 Console.WriteLine("Transform to a GUN...");
           }
      }

      class Bumblebee : Transformer                     //大黄蜂
      {
           public override void Transform()
           {
                 Console.WriteLine("Transform to a CAR...");
           }
      }

      class Starscream : Transformer                    //红蜘蛛
      {
           public override void Transform()
           {
                 Console.WriteLine("Transform to a FIGHTER...");
           }
      }

      class Program                                            //主程序类
      {
           static void Main(string[] args)
           {
                 string number = string.Empty;

                 //只准备一个变量即可，并且不用实例化
                 Transformer transformer;

                 while (true)                                   //无限循环
                 {
                      Console.WriteLine("Please input 1/2/3/4 to choose a transformer...");
                      number = Console.ReadLine();

                      switch (number)                       //根据用户选择，作出响应，运行期"动态"实例化
                      {
                            case "1":
                                  transformer = new OptimusPrime();
                                  break;

                            case "2":
                                  transformer = new Megatron();
                                  break;

                            case "3":
                                  transformer = new Bumblebee();
                                  break;

                            case "4":
                                  transformer = new Starscream();
                                  break;

                            default:
                                  transformer = null;
                                  break;
                      }
                     
                      if (transformer != null)               //这里是本程序的核心
                      {
                            transformer.Transform();
                      }
                      else
                      {
                            Console.WriteLine("Do you want a TRACTOR ??");
                      }
                 }
           }
      }
}
代码分析：

1.        为了展示多态效果，先装备了一个基类。这个基类是一个常规的类――可以实例化、调用其方法。不过，使用抽象类或者接口来展示多态效果也完全没有问题，因此，你把Transformer类替换成下面两种形式也是可以的：
（A）以抽象类做基类

      abstract class Transformer    //基类，这是一个抽象类，方法只有声明没有实现
      {
           abstract public  void Transform();
      }

（B）以接口做基类
      interface Transformer           //基接口，方法只有声明没有实现
      {
            void Transform();
      }
注意：如果使用的是基接口而不是基类，那么实现基接口的时候，方法不再需要override关键字。原因很简单，接口中的方法是没有“实现”的，所以只需要“新写”就可以了、不用“重写”。如下：
      class OptimusPrime : Transformer      //博派老大擎天柱
      {
           public  void Transform()
           {
                 Console.WriteLine("Transform to a TRUCK...");
           }
      }
花絮：
记得有一次公开课上，一个兄弟问我：到底是用常规类合适，还是用抽象类或者用基接口合适呢？如何判断、如何在工程中应用呢？我感觉这个问题问的非常好――这个已经不是C#语言所研究的范畴了，而是软件工程的范畴，确切地说，这是“设计模式”（Design Pattern）的范畴。当你已经对类的封装、继承、多态了如指掌后，不满足于这种小儿科的例子程序而打算用这些知识写出漂亮的软件工程时，那么你会发现：如何设计类、什么应该被设计成类、什么不应该，与耦合，类与类之间如何继承最稳定、最高效，类与类之间如何平衡内聚……这些问题都非常重要却又让你感觉无从下手。那么OK，去看《设计模式》吧，去学习UML吧！恭喜你，你上了一个大台阶！

2.        在本例中，只声明了一个多态变量，而且没有实例化。实例化的步骤挪到case分支里去了。我记得有的书里管这样的形式叫“动态实例化”。

3.        switch…case…分支中，根据用户的选择实例化transform引用变量。

4.        最后的if…else…是程序的核心。在if的true分支里，因为各类的Transform()方法是同名而且是virtual/override继承的，所以能够体现出多态性。

二．牛刀小试
       光写上面那种没什么实际用处的例子程序还真没多大意思，也就唬弄唬弄新手、讲讲原理还行。下面这个例子是多态在实际应用中的一个例子。这个例子在《深入浅出话事件》里提到过，是有关于WinForm程序的事件中那个object类型的sender的。

       OK，让我们来考虑这样一种情况：我在窗体上放置了50个Control和一个ToolTip。现在要求当鼠标指向某一个Control的时候，ToolTip要显示当前所指Control的全名（Full Name）。

呵呵，这个听起来并不难，对吧！你可能会这样想：

1.        获得当前Control的名字，可以用这个Control的ToString()方法。

2.        在每个Control的MouseEnter事件里，让ToolTip显示上一步所获得的字符串就OK了。

3.        比如button1的MouseEnter事件响应函数写出来就应该是这样的：

           private void button1_MouseEnter(object sender, EventArgs e)
           {
                 string fullName = button1.ToString();
                 toolTip1.SetToolTip(button1, fullName);
           }

而comboBox1的MouseEnter事件响应函数则是：

           private void comboBox1_MouseEnter(object sender, EventArgs e)
           {
                 string fullName = comboBox1.ToString();
                 toolTip1.SetToolTip(comboBox1, fullName);
           }

 

唔……窗体里有50个Control，你怎么办呢？

噢！你说可以用“复制/粘贴”然后再改动两处代码？

真是个好主意！！不过，你打算在什么地方出错呢？这种“看起来一样”的复制+粘贴，是Bug的一大来源。况且我这里只有50个Control，如果是500个，你打算怎么办呢？

佛说：前世的500次回眸，换得今生的1次擦肩而过；可他没说今生的500次Ctrl+C/Ctrl+V能在下辈子奖你个鼠标啊:P

OK，我知道你有决心和毅力去仔细完成50次正确的Ctrl+C/Ctrl+V并且把两处代码都正确改完。当你完成这一切之后，市场部的兄弟告诉我们――客户的需求升级了！客户要求在鼠标移向某个Control时不但要显示它的Full Name，而且ToolTip的颜色是随机的！！

>_< …… @#^&(#$%^@#

50处的修改，不要漏掉喔……程序员吐吧吐吧，不是罪！

 

       ……拜OO之神所赐，我们有多态……噩梦结束了。让我们看看多态是如何简化代码、增强可扩展性的。

       首先打开MSDN，我要Show你一点东西。请你分别查找Button类、TextBox类、ListBox类、ComboBox类……它们的ToString()方法。是不是都可以看到这样一句注释：

l          ToString               Overridden.  （这是Button类的，是重写了父类的。）

l          ToString        Returns a string that represents the TextBoxBase control. (Inherited from TextBoxBase.)（这是TextBox的，说是从TextBoxBase继承来的，我们追查一下。）

l          ToString        Overridden. Returns a string that represents the TextBoxBase control.（这是TextBoxBase的，也是重写了父类的。TextBox继承了它，所以仍然是重写的。）

l          ToString        Overridden. Returns a string representation of the ListBox. （这是ListBox的，也明确指出是重写的。）

……

这些Control都是重写的谁的ToString()方法呢？其中的细节我就不说了――这这个重写链的最顶端，是“万类之源”――Object类。也就是说，在Object类中，就已经包含了这个ToString()方法。Object类在C#中正好对应object这个Keyword。

一切问题都解决了！让我们用多态来重构前面的代码！

1.        手动书写（或者改造某个Control的MouseEnter响应函数），成为如下代码：
           private void common_MouseEnter(object sender, EventArgs e)
           {
                 //用户的第一需求：显示ToolTip
                 string fullName = sender.ToString();
                 Control currentControl = (Control)sender;
                 toolTip1.SetToolTip(currentControl, fullName);

                 //用户的第二需求：随机颜色
                 Color[] backColors = new Color[] { Color.CornflowerBlue, Color.Pink, Color.Orange };
                 Random r = new Random();
                 int i = r.Next(0, 3);
                 toolTip1.BackColor = backColors[i];

                 //用户的第N需求：……

           }

 

2.        将这个事件处理函数“挂接”在窗体的每个Control的MouseEvent事件上，方法是：在“属性”面板里切换到Control的“事件”页面（点那个小闪电），然后选中MouseEvent事件，再点击右边的向下箭头，在下拉菜单中会出现上面我们手写的函数――选中它。如图：

3.        为每一个Control的MouseEvent事件挂接这个响应函数。一个简短的、可扩展的程序就完成了！

代码分析：

1.        函数之所以声明成：
private void common_MouseEnter(object sender, EventArgs e){…}
是为了与各Control的MouseEnter事件的委托相匹配。如果你不明白为什么这样做，请仔细阅读《深入浅出话事件》的上下两篇。

2.        核心代码：
string fullName = sender.ToString();
体现了多态。看似是sender的ToString()方法，但由于各个类在激发事件的时候，实际上是以this的身份来发送消息的，this在内存中指代的就是一个具体的Control――如果是button1发送的消息，那么这个this在内存中就是指向的button1，只不过指向这块内存的引用变量是一个object类型的变量――典型的多态。又因为Button类继承自Object类，并且重写了Object的ToString()函数，所以在这里调用sender.ToString()实际上就调用了button1.ToString()。

3.        显式类型转换，为toolTip1的SetToolTip()函数准备一个参数：
Control currentControl = (Control)sender;
其实，这也是多态的体现：子类可以当作任意其父类使用。sender虽然是一个object类型的变量，但它实际上是指向内存中的一个具体的Control实例――MouseEnter事件的拥有者（比如一个Button的实例或者一个TextBox的实例）。而Button、TextBox等类的父类就是Control类，所以完全可以这么用。

4.        后面的代码就非常简单了，不说了。

 

       至此,一个结构清晰,代码简单(只有原来的1/50长度,操作也为原来的1/20不到),便于维护而且扩展性极佳的程序就新鲜出炉了！没有多态，这是不可能实现的。

 

作业：

       自己动手把这个WinForm程序完成，并且确保自己能够分析清楚每句代码的含意。

 

花絮：
       现实当中，WinForm程序的一大部分代码都是由Visual Studio 2005为我们写好的，鳞次栉比、非常好看――但初学者常被搞的晕头转向。没别的办法：大胆打开那些代码、仔细察看、动手跟踪跟踪、修改修改――别怕出错！经验大都是从错误中萃取出来的精华，有时候几十个错误才能为你换来那么一丁点领悟。高手不仅仅是比我们看书多，更重要是犯的错比我们多，呵呵……

 

唉……长舒一口气。

最后我想说的是：要想读懂这些文章，首先要慢慢读――我写它的时候思路是清清楚楚的，但我的思想是我的思想，理解它的时候要一句一句看，说真的，错过一两个字都有可能读不懂。还有就是代码，一定要自己敲一遍。

       如果大家有什么疑问，别客气，在后面跟帖发问就是了。只要有时间，我会一一作答。如果我有哪里写的不对，也请各位高手多多指教，我会立刻更正。

       到此为止，这篇又臭又长的文章可以OVER了――砖我是抛出去了，等您的玉呢！

 

OVER

下期预告：《深入浅出话反射》

本文出自 “上善若水 润物无声” 博客，转载请与作者联系！