AbstractFactory模式

抽象工厂模式解决的问题：

在软件系统中，经常 临着“一系列相互依赖的对象”的创建
   工作；同时，由于需求的变化，往往存在更多系列对象的
   创建工作。

举例说明:

游戏设计场景中需要创建 房屋``道路``地道等并且这写对象是相互联系的。它们组成系列对象。

同时不同的地方会使用不同风格的场景 比如 现代风格 古典风格这就要求多系列对象的创建。

以下三个组成系列对象
// 抽象道路类
public   abstract   class  Road
... {

}
// 抽象房屋
public   abstract   class  Build
... {
 
}
// 抽象地道
public   abstract   class  Tunel
... {
 
}

 创建个抽象工厂类来完成系列对象的创建

// 抽象工厂
public   class  AbstractFactory
... {
    public abstract Road CreatedRoad();
    public abstract Build CreatedBuild();
    public abstract Tunel CreatedTunel();
    public AbstractFactory()
    ...{
        //
        // TODO: 在此处添加构造函数逻辑
        //
    }
}

实例化上面的抽象类， 这里以现代风格为例

// 现代道路
public   class  ModernRoad:Road
... {

}
// 现代房屋
public   class  ModernBuild:Build
... {
 
}
// 现代地道
public   class  ModernTunel:Tunel
... {
 
}
// 现代类型工厂
public   class  ModernFactory:AbstractFactory
... {
    public ModernFactory()
    ...{
    }
    public override Road CreatedRoad()
    ...{
        return new ModernRoad();

    }
    public override Build CreatedBuild()
    ...{
        return new ModernBuild();

    }
    public override Tunel CreatedTunel()
    ...{
        return new ModernTunel();

    }
    
}

以下为客户端代码

// 客户端代码 创建场景
public   class  GameManager
... {
    AbstractFactory AbFactory;
    Road road;
    Build build;
    Tunel tunel;
    public GameManager(AbstractFactory abFactory)//这里可以传入不同风格的工厂

                                                                                                   以创建不同风格的场景从而封装了变化
    ...{
        this.AbFactory = abFactory;
 
    }
    public void BuindGameFactory()
    ...{
        road = AbFactory.CreatedRoad();
        build =AbFactory.CreatedBuild();
        tunel = AbFactory.CreatedTunel();
    }
    public void Run()
    ...{
        road.aaa();
        build.dff();

    }
}

public class App
{
    public static void main()
    {
        GameManager GM = new GameManager(new ModernFactory() );//传入了现代风格的工厂
        GM.BuindGameFactory();//创建现代风格的场景
        GM.Run();
    }
}

Abstract Factory模式的几个要点

* 如果没有应对“多系列对象构建”的需求变化，则没有必要
    使用Abstract Factory模式，这时候使用简单的静态工厂
    完全可以。 比如你游戏场景只要现代风格，那就只要一个系列对象。

*“ 系列对象”指的 这些对象之间有相互依赖、或作用的关
       ，例如游戏开发场景中的“道路”与“房屋”的依赖，“道路”
    与“地道”的依赖。

* Abstract Factory模式主要在于应对“新系列”的需求变动。
    其缺点在于难以应对“新对象”的需求变动。

* Abstract Factory模式经常和Factory Method模式共同组合
    来应对“对象创建”的需求变化。