建立型模式：抽像工厂模式（Abstract Factory）

                                                建立型模式：抽像工厂模式（Abstract Factory）
１、new的问题
常规的对象建立方法：
  // 建立一个Road对象
  Road road = new Road();
new的问题：
－实现依赖，不能应对“具体实例化类型”的变化。
解决思路：
－封装变化点——哪里变化，封装哪里
  －潜台词：若是没有变化，固然不须要额化的封装！
 
２、工厂模式的缘起
  变化点在“对象建立”，所以就封装“对象建立”
  面向接口编程——依赖接口，而非依赖实现
  最简单的解决方法：
  class RoadFactory{       // 类库
    public static Road CreateRoad(){
      return new Road();
      // Road是个抽象类，返回一个特定的工厂
      // return new WaterRoad();
    }
  }
 
  // 客户程序：建立一个Road对象
  Road road = roadFactory.CreateRoad();

３、假设一个游戏开发场景：
  咱们须要构造“道路”、“房屋”，“地道”、“丛林”等对象，咱们须要创建一系列对象，这些对象相互依赖 
Road road = roadFactory.CreateRoad();
...
Building building = roadFactory.CreateBuilding();
...
  以上代码相对稳定
class RoadFactory{
  public static Road CreateRoad(){
    return new Road();    //建立道路
  }
  public static Building CreateBuilding(){
    return new Building();//建立房屋
  }
  public static Tunnel CreateTunnel(){
    return new Tunnel();  //建立地道
  }
  public static Jungle CreateJungle(){
    return new Jungle();  // 建立丛林
  }
}
  纯静态的方法很差，上述代码若是需求改变，它多是变化点
 
４、简单工厂的问题
  不能应对“不一样系列对象”的变化。好比有不一样风格的，游戏场景——对应不一样风格的道路、房屋、地道、丛林等
  如何应对这种变化，如何解决： 使用面向对象的技术来“封装”变化点。
５、动机(Motivation)
    在软件系统中，常常面临着“一系列相互依赖的对象”的建立工做；同时，因为需求的变化，每每存在更多系列对象的建立工做。
    如何应对这种变化？如何绕过常规的对象建立方法（new），提供一种“封装机制”来避名免客户程序和这种“多系列具体对象建立工做”的紧耦合？
６、意图(Intent)
    提供一个接口，让该接口负责建立一系列“相关或者相互依赖的对象”，无需指定它们具体的类。
７、具体实现
//道路
public  abstract class Road
{
}
//房屋
public  abstract class Building 
{
}
//地道
public  abstract class Tunnel
{
}
//丛林
public  abstract class Jungle
{
}

// 第一种风格的设施：现代风格
//道路
public  class ModernRoad : Road
{
}
//房屋
public class ModernBuilding : Building
{
}
//地道
public class ModernTunnel : Tunnel
{
}
//丛林
public class ModernJungle : Jungle
{
}

//抽像工厂:设施工厂
abstract class FacilitiesFactory
{
  public abstract Road CreateRoad();
  public abstract Building CreateBuilding();
  public abstract Tunnel CreateTunnel();
  public abstract Jungle CreateJungle();
}

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();
  }
}

客户程序：整个诊赖于抽象工厂，没有依赖具体的实现，咱们的目的是须要GameManager类稳定下来，不须要变更。
class GameManager
{
  private FacilitiesFactory facilitiesFactory;
  private Road road;
  private Building building;
  private Tunnel tunnel;
  private Jungle jungle;
  public GameManager(FacilitiesFactory facilitiesFactory)
  {
    this.facilitiesFactory = facilitiesFactory;
  }
 
  public void BuildGameGameFacilities()
  {
    road = facilitiesFactory.CreateRoad();
    building = facilitiesFactory.CreateBuilding();
    tunnel = facilitiesFactory.CreateTunnel();
    jungle = facilitiesFactory.CreateJungle();
    //若是设施变化剧烈，这里抽象工厂就是误用，变化剧烈的应该是这些设施的风格
  }
 
  public void Run()
  {
    road.A();
    building.B(road);
    tungle.C();
    jungle.D();
  }
}

class App
{
  public static void Main()
  {
    //只需改这里就行，须要什么风格就new什么风格，这里运行现代风格new ModernFacilitiesFactory()
    FacilitiesFactory facilitiesFactory = new ModernFacilitiesFactory()
    //能够从web.config文件中设置相关，利用.net的反射获得特定风格的工厂
    GameManger gm = new GameManager(facilitiesFactory);
    gm.BuildGameGameFacilities();
    gm.Run();
  }
}

８、Abstract Factory模式的几个要点
  １）若是没有应对“多系列对象构建”的需求变化，则没有必要使用抽像工厂模式，这时候使用简单的静态工厂彻底能够。
  ２）“系列对象”指的是这些对象之间有相互依赖、或做用的关系，例如游戏开发场景中的“道路”的依赖，“道路”与“地道”的依赖。
  ３）抽像工厂模式主要在于应对“新系列”的需求变更。其缺点在于难以应对“新对象”的需求变更。
  ４）抽像工厂模式常常和工厂方法模式共同组合来应对“对象建立”的需求变化。