设计模式之 面向对象的养猪厂的故事,C#演示（二）

(三) 优先使用聚合，而不是继承

有一段时间，养猪场的老板雇用了清洁工人来打扫猪舍。但有一天，老板忽然对自己说"不对啊，既然我有机器人，为什么还要雇人来做这件事情?应该让机器人来打扫宿舍!"
于是，这个需求被提交到了机器人的研发小组。看到这个需求，我们敏感地意识到，这是一个潜藏了更多变化的需求，未来机器人的功能还可能会不断增加，于是，我们提取出了一个抽象的机器人接口，并实现了两个具体的机器人类一-喂猪机器人和清洁机器人。系统的结构如图V8-1所示。



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图V8-1

这样一来，老板希望机器人工作时，可以调用机器人接口的"工作"方法。由于这也是针对接口编程，当老板需要新的机器人时，只要添加具体的机器人类即可，其他代码无需变化。这似乎己经解决了我们遇到的问题。
但这里还存在另外一个问题:图v8-1 中的继承结构是在编译期间就确定了的，在运行期不能发生任何变化。因此，如果养猪场需要一个喂猪机器人和→个清洁机器人，那么我们必须在养猪场中放进这两个具体的机器人。依此类推，如果未来养猪场还需要兽医机器人、屠宰机器人等等，养猪场中不就挤满了机器人吗?更为重要的是，每添加一种机器人的类型，主是们就必须改动代码中的某一个地方，以便把这个机器人放进养猪场中，这就又会违反开闭原则了。在这种情况下，使用聚合的机制能很好地解决问题，因为基于聚合的结构可以在运行期间发生变化。
使用聚合机制的养猪场如图v10-1 所示。我们把机器人接口改成了功能接口，而清洁功能和喂猪功能实现了这个功能接口。真正的机器人类中聚合了一个功能接口的引用，这样，我们只需要在养猪场中放进一个机器人，该机器人中聚合了一个喂猪功能，这时它是一个喂猪机器人。当我们需要打扫养猪场时，老板只需要调用机器人中的"变形"方法，并传递一个"清洁功能"对象给机器人，机器人就会像《变形金刚》中的"擎天柱"一样，大吼一声"汽车人，变形"就变成了-个清洁机器人了。



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图v10-1

面向对象养猪厂V10版本实现代码如下:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace PigFactoryV10
{
/*
*  猪悟能的博客
* http://www.cnblogs.com/hackpig/ *
有一段时间，老板雇用清洁工人打扫猪厂，但有一天，老板对自己说“我有了机器人，为什么还要雇用人打扫猪场？”
于是，软件团队必须开发新的清洁机器人品种
这里，机器人的类型成了变化点

下面的代码使用了聚合方式，把机器人功能变成接口，只要操作员调用“变形”功能，并传入一个“清洁功能”，机器人就会
由喂猪机器人变身为清洁机器人。
如果未来要增加屠宰机器人，原有代码也不用修改。

这里反映出设计模式的第三个核心设计原则：

优先使用聚合而不是继承。
*/

public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
btn_clean.Click += new EventHandler(btn_clean_Click);
btn_feed.Click += new EventHandler(btn_feed_Click);
}

void btn_feed_Click(object sender, EventArgs e)
{
adminMan man1 = new adminMan(1, "大润发养猪场");
this.rtbMsgInfo.Text = man1.Msg;
}

void btn_clean_Click(object sender, EventArgs e)
{
adminMan man1 = new adminMan(2, "大润发养猪场");
this.rtbMsgInfo.Text = man1.Msg;
}
}

public class adminMan:feedPigFactory
{
private string _msg;

public string Msg
{
get { return _msg; }
set { _msg = value; }
}

public adminMan(int funId,string factoryname)
{
base.FactoryName = factoryname;
robot robot1 = null;
switch (funId)
{
case 1:     //喂食
robot1= new robot();
IList<Ipig> list1=new List<Ipig>();
list1.Add(new dbPig(1));
list1.Add(new dbPig(2));
list1.Add(new dbPig(3));
robot1.transformation(new feedPig(list1));
this._msg = robot1.work();
break;
case 2:     //清洁
robot1= new robot();
robot1.transformation(new clean());
this._msg= robot1.work();
break;
default:
break;
}
}

}

public interface IfunInterface
{
string work();
}

public class robot
{
private IfunInterface _robotFun;

public IfunInterface RobotFun
{
get { return _robotFun; }
set { _robotFun = value; }
}

public void transformation(IfunInterface robotFun)
{
this._robotFun = robotFun;
}
public string work()
{
return this._robotFun.work();
}
}

public class clean : IfunInterface
{
public string work()
{
return "正在打扫清洁..."+Environment.NewLine;
}
}

public class feedPig : IfunInterface
{
IList<Ipig> pigList = new List<Ipig>();

public feedPig(IList<Ipig> plist)
{
foreach (Ipig m in plist)
pigList.Add(m);
}

public feedPig()
{
}

public void Attack(Ipig pig)
{
pigList.Add(pig);
}

public string work()
{
string msgstr = string.Empty;
foreach (Ipig m in pigList)
{
msgstr += m.eat() + Environment.NewLine;
}

return string.Format("{0}{1}{2}",
"大润发养猪场" + Environment.NewLine,
"喂猪机器人开始工作...." + Environment.NewLine + Environment.NewLine,
msgstr);
}
}

public abstract class feedPigFactory
{
private string _factoryName;

public string FactoryName
{
get { return _factoryName; }
set { _factoryName = value; }
}

}

public interface Ipig
{

int PigIndex
{
get;
set;
}

string eat();

}

public class cbPig : Ipig
{
private int _pigIndex;

public int PigIndex
{
get { return _pigIndex; }
set { _pigIndex = value; }
}
public cbPig(int pignum)
{
this._pigIndex = pignum;
}

public string eat()
{
return string.Format("{0}[{1}]开始吃.", "长白猪", _pigIndex);
}
}

public class dbPig : Ipig
{
private int _pigIndex;

public int PigIndex
{
get { return _pigIndex; }
set { _pigIndex = value; }
}
public dbPig(int pignum)
{
this._pigIndex = pignum;
}

public string eat()
{
return string.Format("{0}[{1}]开始吃.", "大白猪", _pigIndex);
}
}

}

运行结果如上图所示, 老板可以下达指令在喂食和清洁机器人之间切换了.

代码说明:

在这里,喂猪机器人类是把原来直接调用Work() 喂食方法, 变成了先由transformation()指定功能类型, 再来执行Work().

public class robot
{
private IfunInterface _robotFun;

public IfunInterface RobotFun
{
get { return _robotFun; }
set { _robotFun = value; }
}

public void transformation(IfunInterface robotFun)
{
this._robotFun = robotFun;
}
public string work()
{
return this._robotFun.work();
}
}

而功能类型就是个IfunInterface接口, 而clearn(打扫清洁功能), feedPig(喂猪功能), 都是承继这个接口的.

public interface IfunInterface
{
string work();
}

public class clean : IfunInterface
public class feedPig : IfunInterface

最后利用工厂方法, 决定了机器人在喂食,还是清洁两种功能之间切换.

public adminMan(int funId,string factoryname)
{
base.FactoryName = factoryname;
robot robot1 = null;
switch (funId)
{
case 1:     //喂食
robot1= new robot();
IList<Ipig> list1=new List<Ipig>();
list1.Add(new dbPig(1));
list1.Add(new dbPig(2));
list1.Add(new dbPig(3));
robot1.transformation(new feedPig(list1));
this._msg = robot1.work();
break;
case 2:     //清洁
robot1= new robot();
robot1.transformation(new clean());
this._msg= robot1.work();
break;
default:
break;
}
}

实际上我们是聚合IfunInterface这个抽象接口，即通过指向接口类的引用来访问对象, 这种实现方法其实是综合了聚合与继承两种机制的方式

此后，当我们添加一个新的机器人种类(如兽医机器人)时，只需要添加一个兽医功能的派生类，老板就可以根据自己的需要，在任何时刻命令机器人在三个种类之间随意变形。可以看出，添加一个机器人类型时，需要改动的代码都在系统外部，系统内已有的代码不需要发生变化。这里的聚合机制使我们很好地满足了开闭原则。

总之，继承和聚合是两种各不相同也各有优缺点的机制:

继承反映的是类之间"……是一个……"这样的关系，它在编译期间静态定义。继承的优点是使用起来比较简单(因为面向对象的语言直接支持继承机制)，对设计

人员来说比较容易理解。但继承也有缺点:

首先，你不能在运行期间改变继承树的结构，因为继承是在编译期间定义的:

其次，基类中往往定义了部分的实现，基类的实现暴露给派生类后，继承机制就会破坏数据和操作的封装，使派生类对基类产生较强的依赖O

聚合反映的是类之间"有-个……"或"……包含一个……"的关系，它是在运行期间动态定义的，因此，被聚合对象的类型可以很容易地在运行期间发生变化，只要我们保证它们的接口相同，满足完全替换原则即可。而且，使用聚合可以更好地封装对象，使每一个类集中在单个职能上，类的继承层次也会保持较小的规模，不会造成类数量的爆炸。聚合的缺点是它并不是面向对象语言直接支持的一个特性，用户必须编写一些代码来完成聚合功能。例如，上面机器人类中的"工作"方法就必须把消息转发给内部聚合的功能对象，即调用功能对象的"工作"方法。被聚合对象的接口必须遵从聚合类的要求，这种消息转发的方式又被称为"委托( Delegation ) "。一般来说，聚合的结构比继承更难理解一些。

从上面的分析可以看出，聚合在某些方面比继承更为优越。但我们强调聚合的作用绝不是否定继承的优点。使用聚合时，我们必须遵循针对接口编程的设计原则，不能聚合某一个具体的派生类对象，而应该聚合该类的抽象接口，即通过指向接口类的引用或指针来访问对象----这种实现方法其实是综合了聚合与继承两种机制的方式。

由此，我们可以总结出设计模式的第三个核心设计原则
继承反映的是类之间的"……是一个…"的关系，聚合反映的是类之间"…有一个……"或包含一个……"的关系。在不违反这个关系前提下，应该
优先使用聚合而不是继承, 同时，聚合也必须和接口及相关的继承结构协同使用。

全文完.

本文源代码下载

包括面向对象养猪厂的各种版本实现代码(C#示例), 和VS2010绘制的UML类图.