设计模式 - Abstract Factory模式（抽象工厂模式）

 

Abstract Factory模式（抽象工厂模式）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象，其中创建的实现其实采用的就是Factory模式的方法，对于某个实现的有一个派生出来的抽象工厂，另一个实现有另一个派生出来的工厂。

 

uml图

 

 

抽象基类:

　　1)ProductA,ProductB:分别代表不同类型的产品,而它们的派生类则是这种产品的一个实现.

　　2)AbstractFactory:生产这一系列产品的一个抽象工厂,它的派生类是不同的实现.

接口函数:

　　1)AbstractFactory::CreateProductA和AbstractFactory::CreateProductB:分别是生产不同产品的不同的实现,由各个派生出来的抽象工厂实现之.

解析:

　　Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象,其中创建的实现其实采用的就是Factory模式的方法,对于某个实现

的有一个派生出来的抽象工厂,另一个实现有另一个派生出来的工厂,等等. 

 

　　可以举一个简单的例子来解释这个模式:比如,同样是鸡腿(ProductA)和汉堡(ProductB),它们都可以有商店出售(AbstractFactory),但是有不同的实现,有肯

德基(ConcreateFactory1)和麦当劳(ConcreateFactory2)两家生产出来的不同风味的鸡腿和汉堡(也就是ProductA 和ProductB的不同实现).而负责生产汉堡和鸡腿的就是之前提过的Factory模式了.抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现.显而易见的,如果有n种产品同时有m中不同的实现,那么根据乘法原理可知有n*m个Factory模式的使用. 

 

示例代码：

 1 
 2 // AbstractFactory.h
 3 #ifndef ABSTRACTFACTORY_H
 4 #define ABSTRACTFACTORY_H
 5 
 6 // 抽象基类AbstractProductA,代表产品A的抽象
 7 class AbstractProductA
 8 {
 9 public:
10     AbstractProductA() {}
11     virtual ~AbstractProductA(){};
12 };
13 
14 // 派生类ConcreateProductA1,继承自AbstractProductA,代表产品A的第一种实现
15 class ConcreateProductA1
16     : public AbstractProductA
17 {
18 public:
19     ConcreateProductA1();
20     virtual ~ConcreateProductA1();
21 };
22 
23 // 派生类ConcreateProductA2,继承自AbstractProductA,代表产品A的第二种实现
24 class ConcreateProductA2
25     : public AbstractProductA
26 {
27 public:
28     ConcreateProductA2();
29     virtual ~ConcreateProductA2();
30 };
31 
32 // 抽象基类AbstractProductB,代表产品B的抽象
33 class AbstractProductB
34 {
35 public:
36     AbstractProductB() {}
37     virtual ~AbstractProductB(){};
38 };
39 
40 // 派生类ConcreateProductB1,继承自AbstractProductB,代表产品B的第一种实现
41 class ConcreateProductB1
42     : public AbstractProductB
43 {
44 public:
45     ConcreateProductB1();
46     virtual ~ConcreateProductB1();
47 };
48 
49 // 派生类ConcreateProductB2,继承自AbstractProductB,代表产品B的第二种实现
50 class ConcreateProductB2
51     : public AbstractProductB
52 {
53 public:
54     ConcreateProductB2();
55     virtual ~ConcreateProductB2();
56 };
57 
58 // 抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B
59 class AbstractFactory
60 {
61 public:
62     AbstractFactory(){}
63     virtual ~AbstractFactory(){}
64 
65     virtual AbstractProductA* CreateProductA() = 0;
66     virtual AbstractProductB* CreateProductB() = 0;
67 };
68 
69 // 派生类ConcreateFactory1,继承自AbstractFactory
70 // 生产产品A和产品B的第一种实现
71 class ConcreateFactory1
72     : public AbstractFactory
73 {
74 public:
75     ConcreateFactory1();
76     virtual ~ConcreateFactory1();
77 
78     virtual AbstractProductA* CreateProductA();
79     virtual AbstractProductB* CreateProductB();
80 };
81 
82 // 派生类ConcreateFactory2,继承自AbstractFactory
83 // 生产产品A和产品B的第二种实现
84 class ConcreateFactory2
85     : public AbstractFactory
86 {
87 public:
88     ConcreateFactory2();
89     virtual ~ConcreateFactory2();
90 
91     virtual AbstractProductA* CreateProductA();
92     virtual AbstractProductB* CreateProductB();
93 };
94 
95 #endif

 

 

 

 1 
 2 // AbstractFactory.cpp
 3 #include <iostream>
 4 #include "AbstractFactory.h"
 5 
 6 ConcreateProductA1::ConcreateProductA1()
 7 {
 8     std::cout << "construction of ConcreateProductA1\n";
 9 }
10 
11 ConcreateProductA1::~ConcreateProductA1()
12 {
13     std::cout << "destruction of ConcreateProductA1\n";
14 }
15 
16 ConcreateProductA2::ConcreateProductA2()
17 {
18     std::cout << "construction of ConcreateProductA2\n";
19 }
20 
21 ConcreateProductA2::~ConcreateProductA2()
22 {
23     std::cout << "destruction of ConcreateProductA2\n";
24 }
25 
26 ConcreateProductB1::ConcreateProductB1()
27 {
28     std::cout << "construction of ConcreateProductB1\n";
29 }
30 
31 ConcreateProductB1::~ConcreateProductB1()
32 {
33     std::cout << "destruction of ConcreateProductB1\n";
34 }
35 
36 ConcreateProductB2::ConcreateProductB2()
37 {
38     std::cout << "construction of ConcreateProductB2\n";
39 }
40 
41 ConcreateProductB2::~ConcreateProductB2()
42 {
43     std::cout << "destruction of ConcreateProductB2\n";
44 }
45 
46 ConcreateFactory1::ConcreateFactory1()
47 {
48     std::cout << "construction of ConcreateFactory1\n";
49 }
50 
51 ConcreateFactory1::~ConcreateFactory1()
52 {
53     std::cout << "destruction of ConcreateFactory1\n";
54 }
55 
56 AbstractProductA* ConcreateFactory1::CreateProductA()
57 {
58     return new ConcreateProductA1();
59 }
60 
61 AbstractProductB* ConcreateFactory1::CreateProductB()
62 {
63     return new ConcreateProductB1();
64 }
65 
66 ConcreateFactory2::ConcreateFactory2()
67 {
68     std::cout << "construction of ConcreateFactory2\n";
69 }
70 
71 ConcreateFactory2::~ConcreateFactory2()
72 {
73     std::cout << "destruction of ConcreateFactory2\n";
74 }
75 
76 AbstractProductA* ConcreateFactory2::CreateProductA()
77 {
78     return new ConcreateProductA2();
79 }
80 
81 AbstractProductB* ConcreateFactory2::CreateProductB()
82 {
83     return new ConcreateProductB2();
84 }

 

 

 

 

 1 
 2 // Main.cpp
 3 #include "AbstractFactory.h"
 4 #include <stdlib.h>
 5 
 6 int main()
 7 {
 8     // 生产产品A的第一种实现
 9     ConcreateFactory1 *pFactory1 = new ConcreateFactory1;
10     AbstractProductA *pProductA = pFactory1->CreateProductA();
11 
12     // 生产产品B的第二种实现
13     ConcreateFactory2 *pFactory2 = new ConcreateFactory2;
14     AbstractProductB *pProductB = pFactory2->CreateProductB();
15 
16     delete pFactory1;
17     delete pProductA;
18     delete pFactory2;
19     delete pProductB;
20 
21     system("pause");
22 
23     return 0;
24 }