C#面向对象设计模式纵横谈三之Abstract Factory抽象工厂（建立型模式）

1、new的问题

常规的对象建立方法：

// 建立一个Road对象
Road road =  new Road();

 

new的问题：

1）实现依赖，不能应对“具体实例化类型”的变化

 

解决思路：

1）封装变化点——哪里有变化，就封装哪里

2）潜台词：若是没有变化 ，固然不须要额外的封装

 

2、工厂模式的缘起

1）变化点在“对象建立”，所以就封装“对象建立”

2）面向接口编得不到——依赖接口，而非依赖实现

3）最简单的解决方法：

class RoadFactory
{
     public  static Road CreateRoad()
    {
         return  new Road();
    }
}

class Program
{
     public  static  void Main( string[] args)
    {
         // 建立一个Road对象
        Road road = RoadFactory.CreateRoad();
    }
}

 

3、建立一系列相互依赖的对象

假设一个游戏开发场景：

咱们须要构造“道路”、“房屋”、“地道”、“丛林”...等等对象

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

class Program
{
     public  static  void Main( string[] args)
    {
         // 建立一个Road对象
        Road road = RoadFactory.CreateRoad();

        Building building = RoadFactory.CreateBuilding();
        
        ....
    }
}

 

4、简单工厂的问题

问题：

不能应对“不一样系列对象”的变化。好比有不一样风格的游戏场景——对应不一样风格的道路、房屋、地道...

解决：

使得面向对象的技术来“封装”变化点

 

5、动机（Motivation）

在软件系统中，常常面临着“一系列相互依赖的对象”的建立工做；同时、因为需求的变化，每每存在更多系列对象的建立工做。

如何应对这种变化？

如何绕过常规的对象建立方法（new），提供一种“封装机制”来避免客户程序和这种“多系统具体对象建立工做”的紧耦合？

 

6、意图（Intent）

提供一个接口，让该接口负责建立一系列“相关或者相互依赖的对象”，无需指定它们具体的类。

 

7、结构（Structure）

 

8、代码示例

public  class Program
{
     public  static  void Main( string[] args)
    {
        GameManager gameManager =  new GameManager( new ModernFacilitiesFactory());
        gameManager.BulidGameFacilities();
        gameManager.Run();
    }
}

// 道路
public  abstract  class Road
{
    
}

// 房屋
public  abstract  class Building
{
    
}

// 地道
public  abstract  class Tunnel
{
    
}

// 丛林
public  abstract  class Jungle
{
    
}

// 设施
abstract  class FacilitiesFactory
{
     // 建立道路
     public  abstract Road CreateRoad();

     // 建立房屋
     public  abstract Building CreateBuilding();

     // 建立地道
     public  abstract Tunnel CreateTunnel();

     // 建立丛林
     public  abstract Jungle CreateJungle();
}

// 客户程序
public  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 BulidGameFacilities()
    {
        road = facilitiesFactory.CreateRoad();
        building = facilitiesFactory.CreateBuilding();
        tunnel = facilitiesFactory.CreateTunnel();
        jungle = facilitiesFactory.CreateJungle();
    }

     public  void Run()
    {
        
    }
}

// 道路
public  class ModernRoad : Road
{
    
}

// 房屋
public  class ModernBuilding : Building
{
    
}

// 地道
public  class ModernTunnel : Tunnel
{
    
}

// 丛林
public  class ModernJungle : Jungle
{
    
}

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

 

10、Abstract Factory模式的几个要点

1）若是没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时侯使用简单的静态工厂彻底能够。

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

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

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