WebCast听课录(4)

课程名： C#面向对象设计模式纵横谈(3)：Abstract Factory 抽象工厂模式(创建型模式) 

   创建型模式要解决的问题就是如何创建一个对象的问题。使用new的问题在于： 实现依赖，不能应对“具体实例化类型”的变化。这个问题的解决思路是： 封装变化点—— 哪里变化，封装哪里。

//  创建一个Road 对象
Road road =  
roadFactory.CreateRoad(); 

如果以后Road类改变了，例如从泥土路变成了水泥路，那么代码就必须要进行大量修改。

关键就是如何封装变化点，将变化与系统其他稳定的部分隔离开，使其的更改不会对稳定部分产生影响

 

既然变化点在“对象创建”，因此就封装“对象创建” ，原则是：面向接口编程——依赖接口，而非依赖实现。

 

最简单的解决方法：

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

假设一个场景：需要构造“道路”、“房屋”、“地道”、“丛林”……等等对象.

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

简单工厂的问题：不能应对“不同系列对象”的变化。比如有不同风格的游戏场景——对应不同风格的道路、房屋、地道等。解决办法：使用面向对象的技术来“封装”变化点。

 

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

 

意图：提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。——《设计模式》GoF

 

     public   abstract   class  Road
     {

    }
     public   abstract   class  Building
     {

    }


     public   abstract   class  FacilitiesFactory
     {
        public abstract  Road CreateRoad();

        public abstract  Building CreateBuilding();

    }

    
     public    class  ModernRoad:Road
     {
        public ModernRoad()
        {
        }
    }
     public    class  ModernBuilding:Building
     {
        public ModernBuilding()
        {
        }
    }


     public   class  ModernFacilitiesFactory : FacilitiesFactory
     {
        public ModernFacilitiesFactory()
        {
        }
        public override Road CreateRoad()
        {
            return new ModernRoad();
        }

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

     class  GameManager
     {
        FacilitiesFactory facilitiesFactory;
        Road road;
        Building building;
        public GameManager(FacilitiesFactory facilitiesFactory)
        {
            this.facilitiesFactory = facilitiesFactory;
        }

        public void BuildGameFacilities()
        {
            this.road = this.facilitiesFactory.CreateRoad();
            this.building = this.facilitiesFactory.CreateBuilding();

        }

        public void Play()
        {
            //.
        }


    }

     class  Test
     {

        public static void Main(String[] args)
        {
            GameManager g = new GameManager(new ModernFacilitiesFactory());
            g.BuildGameFacilities();
            g.Play();
        }

    }

Abstract Factory模式的几个要点

 

1，如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的静态工厂完全可以。

 

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

 

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

 

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