2.抽象工厂（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.当你提供一个产品类库，而只想显示它们的接口不是实现时。
生活例子：
               
结构图代码实现：

    public abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();

        public abstract AbstractProductB CreateProductB();
    }

    public class ConcreteFactory1 : AbstractFactory
    {

        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }

        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    public class ConcreteFactory2 : AbstractFactory
    {

        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }

        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }

 

    public abstract class AbstractProductA
    {
        public abstract void Interact(AbstractProductB b);
    }

    public class ProductA1 : AbstractProductA
    {
        public override void Interact(AbstractProductB b)
        {
            Console.WriteLine(this.GetType().Name + "interact with " + b.GetType().Name);
        }
    }

    public class ProductA2 : AbstractProductA
    {
        public override void Interact(AbstractProductB b)
        {
            Console.WriteLine(this.GetType().Name + "interact with " + b.GetType().Name);
        }
    }

    public abstract class AbstractProductB
    {
        public abstract void Interact(AbstractProductA a);
    }

    public class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name + " interact with " + a.GetType().Name);
        }
    }

    public class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name + " interact with " + a.GetType().Name);
        }
    }

 

  

    public class Client
    {
        private AbstractProductA AbstractProductA;
        private AbstractProductB AbstractProductB;

        public Client(AbstractFactory factory)
        {
            AbstractProductA = factory.CreateProductA();
            AbstractProductB = factory.CreateProductB();
        }

        public void Run()
        {
            AbstractProductA.Interact(AbstractProductB);
            AbstractProductB.Interact(AbstractProductA);
        }
    }

        public static void Main()
        {
            // Abstractfactory1
            AbstractFactory factory1 = new ConcreteFactory1();
            Client c1 = new Client(factory1);
            c1.Run();

            //Abstractfactory1
            AbstractFactory factory2 = new ConcreteFactory2();
            Client c2 = new Client(factory2);
            c2.Run();
        }

 

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