面向对象设计模式之AbstractFactory抽象工厂模式（创建型）

动机：在软件系统中，经常面临着“系列相互依赖的对象”的创建工作：同时，由于需求的变化，往往存在更多系列对象 的创建工作；如何应对这种变化？如何绕过常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？
意图：提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。

适用性：

一个系统要独立于它的产品的创建、组合和表示时。

一个系统要由多个产品系列中的一个来配置时。

当你要强调一系列相关的产品对象的设计以便进行联合使用时。

当你提供一个产品类库，而只想显示它们的接口而不是实现时。
UML图：



示例代码：游戏场景中AbstractFactory模式的应用

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

namespace AbstractFactory
{
#region 一系列对象的抽象类定义
/// <summary>
/// 路（抽象类）
/// </summary>
public abstract class Road
{

}

/// <summary>
/// 房屋（抽象类）
/// </summary>
public abstract class Building
{

}

/// <summary>
/// 隧道（抽象类）
/// </summary>
public abstract class Tunnel
{

}
/// <summary>
/// 丛林（抽象类）
/// </summary>
public abstract class Jungle
{

}
#endregion

#region 一系列具体实例对象类的定义

#region 现代风格的一系列对象
/// <summary>
/// 现代风格的路
/// </summary>
public  class ModernRoad:Road
{

}

/// <summary>
/// 现代风格的房屋
/// </summary>
public class ModernBuilding:Building
{

}

/// <summary>
/// 现代风格的隧道
/// </summary>
public class ModernTunnel:Tunnel
{

}
/// <summary>
/// 现代风格的丛林
/// </summary>
public class ModernJungle:Jungle
{

}
#endregion

#region 古代风格的一系列类
/// <summary>
/// 古老风格的路
/// </summary>
public class AncientRoad : Road
{

}

/// <summary>
/// 古老风格的房屋
/// </summary>
public class AncientBuilding : Building
{

}

/// <summary>
/// 古老风格的隧道
/// </summary>
public class AncientTunnel : Tunnel
{

}
/// <summary>
/// 古老风格的丛林
/// </summary>
public class AncientJungle : Jungle
{

}
#endregion

#endregion

/// <summary>
/// 场景设施抽象创建工厂类
/// </summary>
public abstract class FacilitiesFactory
{
public abstract Road CreateRoad();
public abstract Building CreateBuilding();
public abstract Tunnel CreateTunnel();
public abstract Jungle CreateJungle();
}

/// <summary>
/// 现代风格的对象创建工厂类
/// </summary>
public class ModernFacilitiesFactory : FacilitiesFactory
{

public override Road CreateRoad()
{
return new ModernRoad();
}

public override Building CreateBuilding()
{
return new ModernBuilding();
}

public override Tunnel CreateTunnel()
{
return new ModernTunnel();
}

public override Jungle CreateJungle()
{
return new ModernJungle();
}
}

/// <summary>
/// 古代风格的对象创建工厂类
/// </summary>
public class AncientFacilitiesFactory : FacilitiesFactory
{

public override Road CreateRoad()
{
return new AncientRoad();
}

public override Building CreateBuilding()
{
return new AncientBuilding();
}

public override Tunnel CreateTunnel()
{
return new AncientTunnel();
}

public override Jungle CreateJungle()
{
return new AncientJungle();
}
}

客户程序实现代码：

/// <summary>
/// 假设此类为客户程序
/// </summary>
public class GameManager
{
/***
* 当需要增加另一种风格的场景时，只需要继承对应的抽象类实现此风格下的实例对象类和具体工厂类即可
* 而客户程序无需改动或改动甚少，这既是这种设计模式的优势
* ***/
FacilitiesFactory _facilitiesfactory;
Road road;
Building building;
Tunnel tunnel;
Jungle jungle;
public GameManager(FacilitiesFactory facilitiesfactory )
{
this._facilitiesfactory = facilitiesfactory;
}

/// <summary>
/// 创建游戏场景
/// </summary>
public void BuildGameFacilities()
{
road = _facilitiesfactory.CreateRoad();
building = _facilitiesfactory.CreateBuilding();
tunnel = _facilitiesfactory.CreateTunnel();
jungle = _facilitiesfactory.CreateJungle();
}

/// <summary>
/// 开始游戏
/// </summary>
public void Play()
{

}
}

}

public class App
{
public static void Main()
{
FacilitiesFactory ff = new ModernFacilitiesFactory();
GameManager game = new GameManager(ff);
game.BuildGameFacilities();
game.Play();
}
}

注：本示例代码是本人学习Webcast C#面向对象设计模式纵横谈系列讲座视频时，跟着李建忠老师一步一步的编写的，在此奉献出来，仅供大家参考