开发设计模式（八）抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式主要有以下角色：

抽象工厂角色：担任这个角色的是工厂方法模式的核心，它是与应用系统的商业逻辑无关的。通常使用接口或抽象类实现。
具体工厂角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。通常使用具体的类实现。
抽象产品角色：担任这个角色的类是抽象工厂方法模式所创建的对象的父类，或它们共同拥有的接口。通常使用接口或抽象类实现这一角色。
具体产品角色：抽象工厂模式所创建的任何产品对象都是某一具体产品类的实例。这是客户端最终需要的东西。通常使用具体类实现这个角色。

好了，我们继续上一节课，上一节讲到女娲造人，人是造出来了，世界时热闹了，可是低头一看，都
是清一色的类型，缺少关爱、仇恨、喜怒哀乐等情绪，人类的生命太平淡了，女娲一想，猛然一拍脑袋，
Shit！忘记给人类定义性别了，那怎么办？抹掉重来，然后就把人类重新洗牌，准备重新开始制造人类。
由于先前的工作已经花费了很大的精力做为铺垫，也不想从头开始了，那先说人类（Product 产品类）
怎么改吧，好，有了，给每个人类都加一个性别，然后再重新制造，这个问题解决了，那八卦炉怎么办？
只有一个呀，要么生产出全都是男性，要不都是女性，那不行呀，有了，把已经有了一条生产线——八卦
炉（工厂模式中的Concrete Factory）拆开，于是女娲就使用了“八卦拷贝术”，把原先的八卦炉一个变两
个，并且略加修改，就成了女性八卦炉（只生产女性，一个具体工厂的实现类）和男性八卦炉（只生产男
性，又一个具体工厂的实现类。

详细的注释都在下面代码中：

using UnityEngine;
using System.Collections;
using System;

public class AbstractFactory : MonoBehaviour {

// Use this for initialization
void Start () {
MainClass.Main();
}

// Update is called once per frame
void Update () {

}
}

// 定义一个人类的接口 //
interface AHuman
{
void Laugh();
void Talk();
void Sex();
}
// 以下是黄种人的抽象类 //
abstract class AbstractYellowHuman
{
public void Laugh()
{
Debug.Log("..................黄种人会笑");
}
public void Talk()
{
Debug.Log("..................黄种人会说话");
}
}
// 以下是白种人的抽象类 //
abstract class AbstractWhiteHuman
{
public void Laugh()
{
Debug.Log("..................白种人会笑");
}
public void Talk()
{
Debug.Log("..................白种人会说话");
}
}
// 以下是黄种女人实现类 //
class YellowFemaleHuman : AbstractYellowHuman, AHuman
{
public void Sex()
{
Debug.Log("................黄种人女性");
}
}
// 以下是黄种男人实现类 //
class YellowMaleHuman : AbstractYellowHuman, AHuman
{
public void Sex()
{
Debug.Log(".................黄种人男人");
}
}
// 以下是白种女人实现类 //
class WhiteFemaleHuman : AbstractWhiteHuman, AHuman
{
public void Sex()
{
Debug.Log("...............白种人女性");
}
}
// 以下是白种男人实现类 //
class WhiteMaleHuman : AbstractWhiteHuman, AHuman
{
public void Sex()
{
Debug.Log(".................白种人男人");
}
}
// 抽象工厂的模式下，产品等级和产品类都定义好了，下一步就是等工厂开工了 //
// 用枚举对于传参的好处不言而喻 //
enum HumanEnum
{
YellowMaleHuman,
YellowFemaleHuman,
WhiteMaleHuman,
WhiteFemaleHuman
}
// 工厂总接口，定义2个工厂，一个是黄种人工厂，一个是白种人工厂 //
interface AHumanFactory
{
AHuman CreateYellowHuman();
AHuman CreateWhiteHuman();
}
// 定义抽象工厂, 目的就是减少下边实现类的代码量 //
abstract class AbastractHumanFactory
{
protected AHuman CreateHuman(HumanEnum humanEnum)
{
System.Type type = System.Type.GetType(GetStringByEnum(humanEnum), true);
AHuman human = (AHuman)System.Activator.CreateInstance(type);
Debug.Log("---" + human);
return human;
}
string GetStringByEnum(object val)
{
if (System.Enum.IsDefined(typeof(HumanEnum), val))
{
return ((HumanEnum)Enum.Parse(typeof(HumanEnum), val.ToString(), true)).ToString();
}
return null;
}
}
// 在这里我们能看到使用HumanEnum的好处了，无需判断是否为空，直接传人类型 //
// 实现男性工厂 //
class MaleHumanFactory : AbastractHumanFactory, AHumanFactory
{
// 创建一个男性黄种人 //
public AHuman CreateYellowHuman()
{
Debug.Log("创造黄种男人");
return CreateHuman(HumanEnum.YellowMaleHuman);
}
// 创建一个男性白种人 //
public AHuman CreateWhiteHuman()
{
Debug.Log("创造白种男人");
return CreateHuman(HumanEnum.WhiteMaleHuman);
}
}
// 实现女性工厂 //
class FemaleHumanFactory : AbastractHumanFactory, AHumanFactory
{
// 创建一个女性黄种人 //
public AHuman CreateYellowHuman()
{
return this.CreateHuman(HumanEnum.YellowFemaleHuman);
}
// 创建一个女性白种人 //
public AHuman CreateWhiteHuman()
{
return this.CreateHuman(HumanEnum.WhiteFemaleHuman);
}
}
// 产品定义好了，工厂也有了，万事俱备只欠东风，女娲开始造人了 //
class MainClass
{
public static void Main()
{
// 第一条生产线，男性生产线 //
AHumanFactory maleHumanFactory = new MaleHumanFactory();
// 第二条生产线，女性生产线 //
AHumanFactory femaleHumanFactory = new FemaleHumanFactory();

// 生产线建立完毕，男性生产线生产黄种人 //
AHuman maleYellowHuman = maleHumanFactory.CreateYellowHuman();
maleYellowHuman.Sex();
maleYellowHuman.Laugh();

// 生产线建立完毕，男性生产线生产白种人 //
AHuman maleWhiteHuman = maleHumanFactory.CreateWhiteHuman();
maleWhiteHuman.Sex();
maleWhiteHuman.Laugh();

// 下面你懂的.... //
}
}

两个八卦炉，一个造女的，一个造男的，开足马力，一直造到这个世界到现在这个模式为止。
抽象工厂模式讲完了，那我们再思考一些问题：工厂模式有哪些优缺点？先说优点，我这人一般先看
人优点，非常重要的有点就是，工厂模式符合OCP 原则，也就是开闭原则，怎么说呢，比如就性别的问题，
这个世界上还存在双性人，是男也是女的人，那这个就是要在我们的产品族中增加一类产品，同时再增加
一个工厂就可以解决这个问题，不需要我再来实现了吧，很简单的大家自己画下类图，然后实现下。
那还有没有其他好处呢？抽象工厂模式，还有一个非常大的有点，高内聚，低耦合，在一个较大的项
目组，产品是由一批人定义开发的，但是提供其他成员访问的时候，只有工厂方法和产品的接口，也就是
说只需要提供Product Interface 和Concrete Factory 就可以产生自己需要的对象和方法，高内聚
低耦合的特性表现的一览无遗，