對象建立型模式------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();
}