对象创建型模式------Abstract Factory(抽象工厂）

1. 意图
    提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
2. 别名
    Kit
3. 动机
        假设我们要开发一款游戏，当然为了吸引更多的人玩，游戏难度不能太大 （让大家都没有信心了，估计游戏也就没有前途了），但是也不能太简单 （没有挑战性也不符合玩家的心理）。于是我们就可以采用这样一种处理策略：为游戏设立等级，初级、中级、高级甚至有BT 级。假设也是过关的游戏，每个关卡都有一些怪物 （monster）守着，玩家要把这些怪物干掉才可以过关。作为开发者，我们就不得不创建怪物的类，然后初级怪物、中级怪物等都继承自怪物类（当然不同种类的则需要另创建类，但是模式相同）。在每个关卡，我们都要创建怪物的实例，例如初级就创建初级怪物（有很多种类）、中级创建中级怪物等。可以想象在这个系统中，将会有成千上万的怪物实例要创建，问题是还要保证创建的时候不会出错:初级不能创建 BT  级的怪物（玩家就郁闷了，玩家一郁闷，游戏也就挂挂了），反之也不可以。
     AbstractFactory 模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。 

4.适用性

      ①一个系统要独立于它的产品的创建、组合和表示时。

      ②一个系统要由多个产品系列中的一个来配置时。
      ③当你要强调一系列相关的产品对象的设计以便进行联合使用时。
      ④当你提供一个产品类库，而只想显示它们的接口而不是实现时。

5.参与者

      ①AbstractFactory(WidgetFactory)：声明一个创建抽象产品对象的操作接口。

      ②Concreteactory(MotifWidgetFactory，PMWidgetFactory):实现创建具体产品对象的操作。
      ③AbstractProduct(Windows，ScrollBar):为一类产品对象声明一个接口。
      ④ConcreteProduct(MotifWindow，MotifScrollBar):定义一个将被相应的具体工厂创建的产品对象;实现AbstractProduct接口。
      ⑤Client:仅使用由AbstractFactory和AbstractProduct类声明的接口。

6.协作

      ①通常在运行时刻创建一个ConcreteFactroy类的实例。这一具体的工厂创建具有特定实现的产品对象。为创建不同的产品对象，客户应使用不同的具体工厂。       ②AbstractFactory将产品对象的创建延迟到它的ConcreteFactory子类。 7.优缺点

       ①它分离了具体的类AbstractFactory模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程，它将客户与类的实现分离。客户通过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离；它们不出现在客户代码中。

      ②它使得易于交换产品系列 一个具体工厂类在一个应用中仅出现一次—即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建了一个完整的产品系列，所以整个产品系列会立刻改变。在我们的用户界面的例子中，我们仅需转换到相应的工厂对象并重新创建接口，就可实现从Motif窗口组件转换为Presentation Manager窗口组件。       ③它有利于产品的一致性 当一个系列中的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要。而AbstractFactory很容易实现这一点。       ④难以支持新种类的产品 难以扩展抽象工厂以生产新种类的产品。这是因为AbstractFactory接口确定了可以被创建的产品集合。 支持新种类的产品就需要扩展该工厂接口，这将涉及AbstractFactory类及其所有子类的改变。我们会在实现一节讨论这个问题的一个解决办法。

8.讨论

      AbstractFactory 模式和 Factory 模式的区别是初学（使用）设计模式时候的一个容易引起困惑的地方。实际上，AbstractFactory 模式是为创建一组 （有多类）相关或依赖的对象提供创建接口，而Factory 模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory 模式通常都是使用 Factory 模式实现（ConcreteFactory1 ）。

#include<iostream>
class AbstractProductA{
public:
                 virtual ~ AbstractProductA(){}
protected:
                AbstractProductA(){}
};
class AbstractProductB{
public:
                 virtual ~ AbstractProductB(){}
protected:
                AbstractProductB(){}
};
class ProductA1:public AbstractProductA{
public:
                ProductA1(){std::cout<< "ProductA1..."<<std::endl;}
};
class ProductA2:public AbstractProductA{
                 public:
                ProductA2(){std::cout<< "ProductA2..."<<std::endl;}
};
class ProductB1:public AbstractProductB{
                 public:
                ProductB1(){std::cout<< "ProductB1..."<<std::endl;}
};
class ProductB2:public AbstractProductB{
                 public:
                ProductB2(){std::cout<< "ProductB2..."<<std::endl;}
};
class AbstractFactory{
public:
                 virtual ~AbstractFactory(){}
                 virtual AbstractProductA* CreateProductA()=0;
                 virtual AbstractProductB* CreateProductB()=0;
protected:
                AbstractFactory(){}
};
class ConcreteFactory1:public AbstractFactory{
public:
                AbstractProductA* CreateProductA(){ return new ProductA1();}
                AbstractProductB* CreateProductB(){ return new ProductB1();}
};
class ConcreteFactory2:public AbstractFactory{
public:
                AbstractProductA* CreateProductA(){ return new ProductA2();}
                AbstractProductB* CreateProductB(){ return new ProductB2();}
};
int main(){
                AbstractFactory * cf1 = new ConcreteFactory1();
                cf1->CreateProductA();
                cf1->CreateProductB();
                AbstractFactory * cf2 = new ConcreteFactory2();
                cf2->CreateProductA();
                cf2->CreateProductB();
}