抽象工厂(Abstract Factory)

常规的对象创建方法:

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

new 的问题:
    实现依赖,不能应对“具体实例化类型”的变化。
解决思路:
    封装变化点-----哪里变化,封装哪里
    潜台词: 如果没有变化,当然不需要额外的封装!

工厂模式的缘起
    变化点在“对象创建”,因此就封装“对象创建”
    面向接口编程----依赖接口,而非依赖实现
最简单的解决方法:

class RoadFactory{
    	public static Road CreateRoad()
   	{                                
     		return new Road();   
  	 }
 }
 //创建一个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();
         }
     }

调用方式如下:

         Road road =  RoadFactory.CreateRoad();
         Building building = RoadFactory.CreateBuilding();
         Tunnel tunnel = RoadFactory.CreateTunnel();
         Jungle jungle = RoadFactory.CreateJungle();

如上可见简单工厂的问题:
    不能应对"不同系列对象"的变化。比如有不同风格的场景---对应不同风格的道路,房屋、地道....

如何解决:
    使用面向对象的技术来"封装"变化点。
动机(Motivate):
    在软件系统中,经常面临着"一系统相互依赖的对象"的创建工作:同时,由于需求的变化,往往存在更多系列对象的创建工作。
    如何应对这种变化?如何绕过常规的对象创建方法(new),提供一种"封装机制"来避免客户程序和这种"多系列具体对象创建工作"的紧耦合?

意图(Intent):
    提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
                                                 ----《设计模式》GOF

 结构图(Struct):

适用性:
    
1.一个系统要独立于它的产品的创建、组合和表示时。
    2.一个系统要由多个产品系统中的一个来配置时。
    3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。
    4.当你提供一个产品类库,而只想显示它们的接口不是实现时。

结构图代码实现:

  abstract class AbstractFactory
     {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
     }
   abstract class AbstractProductA
     {
        public abstract void Interact(AbstractProductB b);
     }
   abstract class AbstractProductB
     {
        public abstract void Interact(AbstractProductA a);
     }
    class Client
     {
         private AbstractProductA AbstractProductA;
        private AbstractProductB AbstractProductB;
         public Client(AbstractFactory factory)
        {
             AbstractProductA = factory.CreateProductA();
             AbstractProductB = factory.CreateProductB();           
         }
         public void Run()
         {
             AbstractProductB.Interact(AbstractProductA);
             AbstractProductA.Interact(AbstractProductB);
         }
     }
class ConcreteFactory1:AbstractFactory
     {
         public override AbstractProductA CreateProductA()
         {
             return new ProductA1();
        }
         public override AbstractProductB CreateProductB()
         {
             return new ProductB1();
         }
     }
 class ConcreteFactory2:AbstractFactory
     {
         public override AbstractProductA CreateProductA()
         {
             return new ProdcutA2();
         }
         public override AbstractProductB CreateProductB()
         {
             return new ProductB2();
         }
     }
class ProductA1:AbstractProductA
     {
         public override void Interact(AbstractProductB b)
         {
             Console.WriteLine(this.GetType().Name + "interact with" + b.GetType().Name);
         }
     }
   class ProductB1:AbstractProductB
     {
         public override void Interact(AbstractProductA a)
        {
             Console.WriteLine(this.GetType().Name + "interact with" + a.GetType().Name);
         }
     }
class ProdcutA2:AbstractProductA
     {
         public override void Interact(AbstractProductB b)
         {
             Console.WriteLine(this.GetType().Name + "interact with" + b.GetType().Name);
         }
     }
class ProductB2:AbstractProductB
     {
        public override void Interact(AbstractProductA a)
         {
             Console.WriteLine(this.GetType().Name + "interact with" + a.GetType().Name);
         }
     }
 public static void Main()
         {
          // Abstractfactory1
             AbstractFactory factory1 = new ConcreteFactory1();
             Client c1 = new Client(factory1);
             c1.Run();
         // Abstractfactory2
             AbstractFactory factory2 = new ConcreteFactory2();
             Client c2 = new Client(factory2);
             c2.Run();
         }

Abstract Factory注意的几点:
    如果不存在”多系列对象创建“的需求变化,则没必要应用Abstract Factory模式,静态工厂方法足矣。
    "系列对象"指的是这些对象之间有相互依赖、或作用的关系。例如游戏开发场景中的"道路"与"房屋"依赖,“道路”与“地道”的依赖。
Abstract Factory模式主要在于应对"新系列"的需求变动。其缺点在于难以应对”新对象“的需求变动。
Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值