Abstract Factory（抽象工廠）模式（附代碼）

1.意圖

    提供一個創建一系列相關或相互依賴對象的介面，而無需制定它們具體的類。

2.適用性

•  一個系統要獨立於它的產品創建、組合和表示時。
• 一個系統要由多個產品系列中的一個來配置時。
• 當你強調一系列相關的產品對象的設計以便進行聯合使用時。
• 當你提供一個產品的類庫，而只想顯示它們的介面而不是實現時。

3.結構圖

    如上圖所示為抽象工廠的結構圖，每一個工廠負責創建一系列產品。

4.C++代碼實例

#include <cstdlib>
#include <string>
class AbstractFactory;

class Client
{
public:
    Client(){};
    ~Client(){};
    AbstractFactory *GetFactory(std::string type);
private:
    AbstractFactory *pFactory;

};

 1 class AbstractProductA
 2 {
 3 public:
 4     AbstractProductA()
 5     {
 6     }
 7     virtual ~AbstractProductA()
 8     {
 9     };
10 };
11 
12 
13 class AbstractProductB
14 {
15 public:
16     AbstractProductB()
17     {
18     }
19     virtual ~AbstractProductB()
20     {
21     };
22 };

 1 class AbstractProductA;
 2 class AbstractProductB;
 3 
 4 class AbstractFactory
 5 {
 6 public:
 7      AbstractFactory()
 8      {
 9      };
10      ~AbstractFactory(){};
11     virtual AbstractProductA * CreateProductA()=0;
12     virtual AbstractProductB * CreateProductB()=0;
13 };

 1 #include "AbstractFactory.h"
 2 
 3 class AbstractProductA;
 4 class AbstractProductB;
 5 
 6 class ConcreteFactory1 : public AbstractFactory
 7 {
 8 public:
 9     ConcreteFactory1();
10     ~ConcreteFactory1();
11     AbstractProductA * CreateProductA();
12     AbstractProductB * CreateProductB();
13 };
14 
15 class ConcreteFactory2 : public AbstractFactory
16 {
17 public:
18     ConcreteFactory2();
19     ~ConcreteFactory2();
20     AbstractProductA * CreateProductA();
21     AbstractProductB * CreateProductB();
22 };

 1 #include <cstdio>
 2 #include <cstdlib>
 3 #include <iostream>
 4 #include "AbstractProduct.h"
 5 
 6 class ConcreteProductA1 : public AbstractProductA
 7 {
 8 public:
 9     ConcreteProductA1()
10     {
11         std::cout << "ConcreteProductA1 is Created" << std::endl;
12     }
13     ~ConcreteProductA1()
14     {
15     }
16 };
17 
18 class ConcreteProductA2 : public AbstractProductA
19 {
20 public:
21     ConcreteProductA2()
22     {
23         std::cout << "ConcreteProductA2 is Created" << std::endl;
24     }
25     ~ConcreteProductA2()
26     {
27     }
28 };
29 
30 class ConcreteProductB1 : public AbstractProductB
31 {
32 public:
33     ConcreteProductB1()
34     {
35         std::cout << "ConcreteProductB1 is Created" << std::endl;
36     }
37 
38     ~ConcreteProductB1()
39     {
40     }
41     
42 };
43 
44 class ConcreteProductB2 : public AbstractProductB
45 {
46 public:
47     ConcreteProductB2()
48     {
49         std::cout << "ConcreteProductB2 is Created" << std::endl;
50     }
51 
52     ~ConcreteProductB2()
53     {
54     }
55 };

#include "ConcreteFactory.h"
#include "ConcreteProduct.h"



ConcreteFactory1::ConcreteFactory1()
{
}

ConcreteFactory1::~ConcreteFactory1()
{
}

AbstractProductA * ConcreteFactory1::CreateProductA()
{
    auto product = new ConcreteProductA1();
    return product;
}

AbstractProductB * ConcreteFactory1::CreateProductB()
{
    auto product = new ConcreteProductB1();
    return product;
}


ConcreteFactory2::ConcreteFactory2()
{
}

ConcreteFactory2::~ConcreteFactory2()
{
}

AbstractProductA * ConcreteFactory2::CreateProductA()
{
    auto product = new ConcreteProductA2();
    return product;
}

AbstractProductB * ConcreteFactory2::CreateProductB()
{
    auto product = new ConcreteProductB2();
    return product;
}

#include "Client.h"
#include "ConcreteFactory.h"

 AbstractFactory *Client::GetFactory(std::string type)
 {
     if("1" == type)
     {
         auto pFactory = new ConcreteFactory1();
         return pFactory;
     }
     else if ("2" == type)
     {
         auto pFactory = new ConcreteFactory2();
         return pFactory;
     }
 }

#include "Client.h"
#include "AbstractFactory.h"
#include "AbstractProduct.h"

int main()
{
    auto client = new Client();
    auto pFactory = client->GetFactory("1");
    auto pProductA = pFactory->CreateProductA();
    auto pProductB = pFactory->CreateProductB();
    delete pProductB;
    pProductB = NULL;
    delete pProductA;
    pProductA = NULL;
    delete pFactory;
    pFactory = NULL;

    pFactory = client->GetFactory("2");
    pProductA = pFactory->CreateProductA();
    pProductB = pFactory->CreateProductB();
    delete pProductB;
    pProductB = NULL;
    delete pProductA;
    pProductA = NULL;
    delete pFactory;
    pFactory = NULL;
    delete client;
    client=NULL;

    while(1);
    

}

測試結果：

如測試代碼中所寫，先創建1系列的產品A和B，後創建2系列的產品A和B。

5.效果

• 分離了具體的類，產品的類名不出現在測試代碼（即客戶代碼）中。
• 使得易於交換產品系列。
• 利於產品的一致性。
• 難以支持新種類的產品

6.相關模式

抽象工廠類通常用工廠方法實現，但是也可以用原型實現。一個具體的工廠通常是一個單件。