设计模式系列-工厂模式 推荐

今天回家一开灯感觉客厅的灯暗了许多，抬头一看原来是灯泡快坏了，想想这个灯泡也是老式的不如换个新的节能灯泡算了。于是跑到小区对面的德尔泰市场买了同样接口的节能灯泡，这样光线又好又可以为自己节约电费，回来后迅速拿起凳子，换了新灯泡感觉亮堂了许多。高兴之余就想用代码去模拟一下这个场景。

1、案例设想

设想如果我们编写一个程序通过声控感应设备去控制灯光的显示，那么如何实现呢？我想首先第一步就是需要设计当感应设备捕获到人的时候如何处理，第二部就是在处理内部控制灯泡发光，例如声控设备感应到人的时候，控制我们平时的普通灯泡去发光。通过面向对象封装模拟的代码如下：

static void Main(string[] args)
{
//是否感应到人 默认是
bool isOpen = true;

//普通灯泡
Bulb bulb = new Bulb();

//感应是否生效
if (isOpen)//默认生效
{
//感应器控制灯泡发光
Induction induction = new Induction();
induction.Open(bulb);
}
}

/// <summary>
/// 感应器
/// </summary>
public class Induction
{
//打开终端（灯泡）
public void Open(Bulb bulb)
{
//发光
bulb.Luminescence();
}
}
//灯泡
public class Bulb
{
//发光
public void Luminescence()
{
//灯泡发光的实现
}
}

那么这个时候，我又想起了开始我灯泡坏了的事情了，我最后换了个节能的灯泡。那么我在用代码模拟一个节能灯泡的类吧。代码如下：

//节能灯泡
public class FrugalBulb
{
//节能发光
public void FrugalLuminescence()
{
//节能灯泡发光的实现
}
}

那么这个时候我的普通灯泡坏了，为了考虑成本，决定将普通的灯泡替换成节能灯泡，那么就会出现一个问题，当普通灯泡的插孔与节能灯泡的插孔不同时？我们需要将灯泡的插孔也替换掉，并且感应器也要增加对应节能灯泡的调用，这样就大大的增加了替换的成本，不好的替换方式用代码模拟实现如下：

static void Main(string[] args)
{
//是否感应到人 默认是
bool isOpen = true;

//普通灯泡
Bulb bulb = new Bulb();
//节能灯泡
FrugalBulb fBulb = new FrugalBulb();

//感应是否生效
if (isOpen)//默认生效
{
//感应器控制灯泡发光
Induction induction = new Induction();
//拆除原先普通灯泡的接口
//induction.Open(bulb);

//增加节能灯泡的接口
induction.OpenFrugal(fBulb);
}
}

/// <summary>
/// 感应器
/// </summary>
public class Induction
{
//打开终端（灯泡）
public void Open(Bulb bulb)
{
//发光
bulb.Luminescence();
}

//打开节能终端（灯泡）
public void OpenFrugal(FrugalBulb fBulb)
{
//加入节能发光的调用
fBulb.FrugalLuminescence();
}
}

这样的话实际生活中我们替换增加了成本，代码模拟中我们修改了原先的代码页增加了成本，那么如何降低这些成本呢？

2、引入工厂

分析了上面的内容，我们可以看出的问题有：灯泡实际上都是发光，但是发光的接口不一样例如：普通灯泡发光调用的是【Luminescence】而节能灯泡发光需要调用【FrugalLuminescence】，如果今后需要替换另一种灯泡则需要进行很大的改动，那么如何解决这个问题呢？就想我们组装电脑一样，主板、CPU、硬盘等等，它们之间都互相遵循了同样的接口。不管是AMD的CPU、还是Inter的CPU，它们之间都用一种同样的公开接口，将来替换CPU就会很方便，其他硬件同样。

那么我们能不能将我们灯泡也想电脑硬件一样，使用同一的接口进行操作呢？当然没问题。分析一下既然灯泡都是发光，那么我们就可以将灯泡统一一种协议或者叫约定，即所有灯泡将来都以一种接口呈现。代码如下：

//灯泡的约定
public interface IBulb
{
//统一的发光接口
public void Luminescence();
}

有了约定（接口），那么所有的灯泡都遵循这个约定，我们以后如果需要更换灯泡或者引进新品种灯泡，只需要跟替换电脑配件那样，把旧的拔下来新的插上去，代码如下：

//灯泡
public class Bulb : IBulb//实现了灯泡的约定、标准
{
//发光
public void Luminescence()
{
//灯泡发光的实现
}
}

//节能灯泡
public class FrugalBulb : IBulb //实现了灯泡的约定、标准
{
//节能发光
public void Luminescence()
{
//节能灯泡发光的实现
}
}

这个时候我们在来替换一次灯泡看看，模拟代码如下：

static void Main(string[] args)
{
//是否感应到人 默认是
bool isOpen = true;

//普通灯泡
Bulb bulb = new Bulb();
//节能灯泡
FrugalBulb fBulb = new FrugalBulb();

//感应是否生效
if (isOpen)//默认生效
{
//感应器控制灯泡发光
Induction induction = new Induction();

//普通灯泡发光
induction.Open(bulb);

//节能灯泡发光
induction.Open(fBulb);
}
}

/// <summary>
/// 感应器
/// </summary>
public class Induction
{
//打开终端（灯泡）
public void Open(IBulb bulb)
{
//发光
bulb.Luminescence();
}
}

//灯泡的约定
public interface IBulb
{
//统一的发光接口
public void Luminescence();
}
//灯泡
public class Bulb : IBulb//实现了灯泡的约定、标准
{
//发光
public void Luminescence()
{
//灯泡发光的实现
}
}

//节能灯泡
public class FrugalBulb : IBulb //实现了灯泡的约定、标准
{
//节能发光
public void Luminescence()
{
//节能灯泡发光的实现
}
}

这个时候还有个问题，如果我们将来需要支持彩色灯泡怎么办？我们是不是要增加一个彩色灯泡的类实现灯泡的约定接口，还需要在调用方写入调用的代码。这个时候我们就可以使用工厂类维护这些灯泡，例如：我的灯泡工厂，目前可以制造，普通灯泡，节能灯泡，彩色灯泡。以后我们需要其中哪种灯泡，就通知工厂来供货。代码如下：

public class MyBulbFactory
{
public static IBulb GetBulb(string bulbName)
{
IBulb bulb = null;
//告诉我你要什么灯泡,我制造相应的灯泡给你
switch (bulbName)
{
case "bulb":
bulb = new Bulb();
break;
case "frugalbulb":
bulb = new FrugalBulb();
break;
case "colorbulb":
bulb = new ColorBulb();
break;
}
return bulb;
}
}

/// <summary>
/// 感应器
/// </summary>
public class Induction
{
//打开终端（灯泡）
public void Open(IBulb bulb)
{
//发光
bulb.Luminescence();
}
}

//灯泡的约定
public interface IBulb
{
//统一的发光接口
public void Luminescence();
}
//灯泡
public class Bulb : IBulb//实现了灯泡的约定、标准
{
//发光
public void Luminescence()
{
//灯泡发光的实现
}
}

//节能灯泡
public class FrugalBulb : IBulb //实现了灯泡的约定、标准
{
//节能发光
public void Luminescence()
{
//节能灯泡发光的实现
}
}
//彩色灯泡
public class ColorBulb : IBulb
{
//彩色发光
public void Luminescence()
{
//彩色灯泡发光的实现
}
}

这样将来我们需要什么，只需要告诉工厂我要什么，工厂就会给我们提供了统一接口的灯泡，提供我们使用。 主函数调用代码如下：

static void Main(string[] args)
{
//是否感应到人 默认是
bool isOpen = true;

//感应是否生效
if (isOpen)//默认生效
{
//感应器控制灯泡发光
Induction induction = new Induction();

//我需要普通灯泡
IBulb bulb = MyBulbFactory.GetBulb("bulb");
//普通灯泡发光
induction.Open(bulb);

//我需要节能灯泡
IBulb fBulb = MyBulbFactory.GetBulb("frugalbulb");
//节能灯泡发光
induction.Open(fBulb);

//我需要彩色灯泡
IBulb cBulb = MyBulbFactory.GetBulb("colorbulb");
induction.Open(cBulb);
}
}

使用工厂模式，可以有效的减少更换同类部件的成本。

3、抽象类与接口的个人理解

很多人都很迷惑什么时候应该使用接口，什么时候应该使用抽象类呢？

在.NET企业级架构设计一书中，作者对这方面的解释为：“在那些不支持多继承的面向对象语言（例如，java、C#、和 Visual Basic.NET）中，我们一般倾向于使用接口，因为这样其基类仍有挑选的余地，若支持多继承，则是使用上的偏好了。”

融合了上面的概念后，我总结的是，当类型之间存在集成关系时，我们使用抽象类，例如一个抽象类人类，那么男人和女人都是人类，他们之间存在着这种派生关系，当类型之间需要遵循一系列约定或者规则时使用接口，例如男人和女人都要学习，工作等等。

也就是说，类型天生的部分封装成抽象类，后天添加的规则方法，使用接口，代码实现如下【个人理解仅供参考】：

//学习的约定 规则 行为
public interface ILearn
{
public void Learn();
}

//人类是个抽象的类型
public abstract class Person
{
//活动
public virtual void Activity();
}

//男人类
public class Man : Person,ILearn
{
//人类天生的行为
public override void  Activity()
{

}

//后天的行为
public void Learn()
{
//学习追女人
}
}

//女人类
public class Woman : Person,ILearn
{
//人类天生的行为
public override void Activity()
{

}

//后天的行为
public void Learn()
{
//学习被男人追
}
}