设计模式之抽象工厂模式

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

AbstractProductA和AbstractProductB是两个抽象产品，之所以为抽象，是因为它们都有可能有两种不同的实现。

2、AbstractFactory是一个抽象工厂接口，它里面应该包含所有的产品创建的抽象方法。而ConcreteFactory1和ConcreteFactory2就是具体的工厂了。

通常是在运行时刻再创建一个ConcreteFactory类的实例，这个具体的工厂再创建具有特定的产品对象也就是说，为创建不同产品对象，客户端应该使用不同的具体工厂。

UML图如下：

3、抽象工厂模式的优点和缺点

最大的好处便是易于交换产品系列，由于具体工厂类，例如IFactory factory = new AccessFactory()，在一个应用中只需要在初始化的时候出现一次，就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同产品配置。

第二大好处是，它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口实例，产品的具体类名也被具体工厂实现分离，不会出现在客户端的代码上。

缺点：但是将来要是你想增加功能，比如我们现在要增加项目表Project，需要改动哪些地方？

那么至少要增加三个类，AbstractProductC，productC1，productC2，还需要更改AbstractFactory，ConcreteFactory1，ConcreteFactory2才可以完全实现。

4、C++代码实现

[cpp] view plaincopy

1. #include <iostream>  
2. using namespace std;  
3.   
4. //抽象产品类A，  
5. //定义了具体产品类A统一的接口  
6. class AbstractProductA  
7. {  
8. public:  
9.     virtual void ShowNameA() = 0;  
10. };  
11.   
12. //抽象产品类B  
13. //定义了具体产品类B统一的接口  
14. class AbstractProductB  
15. {  
16. public:  
17.     virtual void ShowNameB() = 0;  
18. };  
19.   
20. //抽象工厂，它里面应该包含  
21. //所有产品创建的抽象方法  
22. class AbstractFactory   
23. {  
24. public:  
25.     virtual AbstractProductA * CreateProductA() = 0;  
26.     virtual AbstractProductB * CreateProductB() = 0;  
27. };  
28.   
29. //具体产品  
30. class ProductA1 : public AbstractProductA  
31. {  
32. public:  
33.     void ShowNameA() {  
34.         cout << "product's name A1" << endl;  
35.     }  
36. };  
37.   
38. //具体产品  
39. class ProductA2 : public AbstractProductA  
40. {  
41. public:  
42.     void ShowNameA() {  
43.         cout << "product's name A2" << endl;  
44.     }  
45. };  
46.   
47. //具体产品  
48. class ProductB1 : public AbstractProductB  
49. {  
50. public:  
51.     void ShowNameB() {  
52.         cout << "product's name B1" << endl;  
53.     }  
54. };  
55.   
56. //具体产品  
57. class ProductB2 : public AbstractProductB  
58. {  
59. public:  
60.     void ShowNameB() {  
61.         cout << "product's name B2" << endl;  
62.     }  
63. };  
64.   
65. //具体工厂，创建具有特定  
66. //实现的产品对象  
67. class ConcreteFactory1 : public AbstractFactory  
68. {  
69. public:  
70.     AbstractProductA * CreateProductA() {  
71.         return new ProductA1();  
72.     }  
73.     AbstractProductB * CreateProductB() {  
74.         return new ProductB1();  
75.     }  
76. };  
77.   
78. //具体工厂，创建具有特定  
79. //实现的产品对象  
80. class ConcreteFactory2 : public AbstractFactory  
81. {  
82. public:  
83.     AbstractProductA * CreateProductA() {  
84.         return new ProductA2();  
85.     }  
86.     AbstractProductB * CreateProductB() {  
87.         return new ProductB2();  
88.     }  
89. };  
90.   
91. int main()   
92. {  
93.     AbstractFactory * p_abstract_factory = new ConcreteFactory1();  
94.     AbstractProductA * p_abstract_productA = p_abstract_factory->CreateProductA();  
95.     AbstractProductB * p_abstract_productB = p_abstract_factory->CreateProductB();  
96.     p_abstract_productA->ShowNameA();  
97.     p_abstract_productB->ShowNameB();  
98.   
99.     p_abstract_factory = new ConcreteFactory2();  
100.     p_abstract_productA = p_abstract_factory->CreateProductA();  
101.     p_abstract_productB = p_abstract_factory->CreateProductB();  
102.     p_abstract_productA->ShowNameA();  
103.     p_abstract_productB->ShowNameB();  
104.     return 0;  
105. }