抽象工廠模式

一 概念解釋
定義：抽象工廠模式提供一個創建一系列相關或者相互依賴的對象接口，而無須指明他們的具體類。抽象模式又稱爲Kit模式。是一種對象創建模式。
抽象工廠模式是爲創建一組對象提供了一種解決方案。與工廠方法模式相比抽象工廠模式中的具體工廠不只是創建一種產品，而是負責創建族產品。
引入相關概念：
1 產品等級結構：即產品的繼承結構，比如抽象類是一個矩形，其子類有紅色矩形，藍色矩形，灰色矩形等。
2 產品族 指在同一個工廠生產的，位於不同的產品等級中的一組產品。比如紅色工廠生產的有紅色矩形，紅色圓形，紅色三角形。

二 抽象工廠模式結構圖

AbstractFactory 抽象工廠，聲明一組用於創建一族產品的方法，每一個方法對應一種產品。
ConcreteFactory 具體工廠，實現了抽象工廠中聲明的創建產品的方法，生成一組具體產品，這些產品構成一個產品族，每個產品都位於某個產品等級結構中。
AbstractProduct 抽象產品，爲每種產品聲明接口，在抽象產品中聲明瞭產品所具有的業務方法。
ConcreteProduct，具體產品，定義具體工廠生產的具體產品對象，實現在抽象產品接口中聲明的業務方法。

C++實現的抽象工廠模式

AbstractProductA.h

#include <stdio.h>


class AbstractProductA
{
public:
    AbstractProductA();
    virtual ~AbstractProductA();
    virtual void operationA() = 0;
};

class ProductA_1:public AbstractProductA
{
public:
    ProductA_1();
    virtual ~ProductA_1();
    void operationA();
};

class ProductA_2:public AbstractProductA
{
public:
    ProductA_2();
    ~ProductA_2();
    void operationA();
};

AbstractProductA.cpp

#include "AbstractProductA.h"


AbstractProductA::AbstractProductA(){}

AbstractProductA::~AbstractProductA(){}

ProductA_1::ProductA_1(){}

ProductA_1::~ProductA_1(){}

void ProductA_1::operationA()
{
    printf("hello,operationA for ProductA_1\n");
}

ProductA_2::ProductA_2(){}

ProductA_2::~ProductA_2(){}

void ProductA_2::operationA()
{
    printf("hello,operationA for ProductA_2\n");
}

AbstractProductB.h

#include <stdio.h>


class AbstractProductB
{
public:
    AbstractProductB();
    virtual ~AbstractProductB();
    virtual void operationB() = 0;
};


class ProductB_1:public AbstractProductB
{
public:
    ProductB_1();
    virtual ~ProductB_1();
    void operationB();
};


class ProductB_2:public AbstractProductB
{
public:
    ProductB_2();
    virtual ~ProductB_2();
    virtual void operationB();
};

AbstractProductB.cpp

#include "AbstractProductB.h"


AbstractProductB::AbstractProductB(){}

AbstractProductB::~AbstractProductB(){}

ProductB_1::ProductB_1(){}

ProductB_1::~ProductB_1(){}

void ProductB_1::operationB()
{
    printf("hello,operationB for ProductB_1\n");
}

ProductB_2::ProductB_2(){}

ProductB_2::~ProductB_2(){}

void ProductB_2::operationB()
{
    printf("hello,operationB for ProductB_2\n");
}

AbstractFactory.h

#include "AbstractProductA.h"
#include "AbstractProductB.h"


class AbstractFactory
{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    virtual AbstractProductA * creatProductA() = 0;
    virtual AbstractProductB * creatProductB() = 0;
};


class Factory1:public AbstractFactory
{
public:
    Factory1();
    ~Factory1();
    AbstractProductA * creatProductA();
    AbstractProductB * creatProductB();
};

class Factory2:public AbstractFactory
{
public:
    Factory2();
    ~Factory2();
    AbstractProductA * creatProductA();
    AbstractProductB * creatProductB();
};

AbstractFactory.cpp

#include "AbstractFactory.h"


AbstractFactory::AbstractFactory(){};

AbstractFactory::~AbstractFactory(){};

Factory1::Factory1(){};

Factory1::~Factory1(){};

AbstractProductA * Factory1::creatProductA()
{
    AbstractProductA * temp = NULL;
    temp = new ProductA_1();
    return temp;
}

AbstractProductB * Factory1::creatProductB()
{
    AbstractProductB * temp = NULL;
    temp = new ProductB_1();
    return temp;
}

Factory2::Factory2(){};

Factory2::~Factory2(){};

AbstractProductA * Factory2::creatProductA()
{
    AbstractProductA * temp = NULL;
    temp = new ProductA_2();
    return temp;
}

AbstractProductB * Factory2::creatProductB()
{
    AbstractProductB * temp = NULL;
    temp = new ProductB_2();
    return temp;
}

client.cpp

int main()
{
    AbstractFactory * factory1 = new Factory1();
    AbstractProductA * productA_1 = factory1->creatProductA();
    AbstractProductB * productB_1 = factory1->creatProductB();
    productA_1->operationA();
    productB_1->operationB();

    delete factory1;
    factory1 = NULL;
    delete productA_1;
    productA_1 = NULL;
    delete productB_1;
    productB_1 = NULL;

    AbstractFactory * factory2 = new Factory2();
    AbstractProductA * productA_2 = factory2->creatProductA();
    AbstractProductB * productB_2 = factory2->creatProductB();
    productA_2->operationA();
    productB_2->operationB();

    delete factory2;
    factory2 = NULL;
    delete productA_2;
    productA_2 = NULL;
    delete productB_2;
    productB_2 = NULL;

    system("pause");
}

運行結果：

抽象工廠的優點：
1 隔離具體類的生成，用戶不需要知道什麼被創建，只需要知道由哪個工廠創建。
2 可以非常方便的使用一族中間的不同類型的產品。

缺點：
1 結構太過臃腫，如果產品類型比較多，或者產品族類比較多，就會非常難於管理。
2 添加產品等級結構比較麻煩，所有的工廠都要添加一個方法，違背開閉準則。