23种设计模式学习—abstract factory模式

   不同于singleton模式的实现，singleton模式的实现只使用了面向对象概念中的一个封装，也就是封装了构造函数，不对外可见，对外暴露出一个获取唯一实例的方法，并没有利用到面向对象概念中的继承，多态等高级功能。

abstract factory模式说的是抽象工厂,抽象工厂中继承出了两个实际工厂,这两个实际工厂开始生产对象,两个工厂生产出来的对象风格不同,比如游戏开发中,有一个古典物品工厂,一个现代物品工厂,他们都派生与抽象工厂,都实现了创建计算工具这个方法,而古典工厂中的创建计算工具将返回一个算盘,而现代工厂返回的计算工具是一个计算器,古典工厂中创建的商人是一身汉服的店小二，现代工厂创建的商人是一身西装的小老板，这样在实际游戏中先实例化一个古典工厂，就可以依靠古典工厂得到身穿汉服拿着算盘的店小二，或者依靠现代工厂得到身穿西装拿着计算器的小老板，而不会得到一个身穿汉服却拿着计算器的店小二或者身穿西装而抱着算盘的小老板

这样看来，abstract factory模式最主要的是抽象工厂的实例工厂们可以产生一系列相互依赖或相互协调的对象，abstract factory模式存在的意义就是为了创建各系列的对象而存在的。

abstract factory是为了如果加入新系列的对象可以从容应对，可abstract factory难以从容应对创建新的对象，比如这个时候新加入了一个柜台，这个时候就要新加一个柜台基类，再加松木柜台，玻璃柜台，然后还要在抽象工厂中新加创建柜台，在古典工厂中实现创建柜台并返回松木柜台，在现代工厂中实现创建柜台并返回玻璃柜台，这样就很麻烦。

所以abstract factory抽象工厂模式是用来应对系列对象的扩充，而不是新对象类型的扩充，如果一个经常有新对象类型加入的代码环境中应用的抽象工厂，反而是一种很麻烦的事情。

所以我们就可以总结出一条经验：设计模式误用了不如不用，误用了肯定会弄巧成拙。一定要把面向对象的设计里找到变化点，然后封装变化点。设计模式是为了应对变化的。不变的地方千万不能用设计模式。

抽象工厂的下面是系列工厂,可以生产一系列对象.

抽象工厂模式经常和工厂方法模式配合使用来解决对象创建的需求变化。

下面是《设计模式精解-GoF 23 种设计模式解析附 C 实现源码》中对AbstractFacotry的摘要：

AbstractFactory适用性:
1) 一个系统要独立于它的产品的创建、组合和表示时。
2)一个系统要由多个产品系列中的一个来配置时。
3) 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
4) 当你提供一个产品类库,而只想显示它们的接口而不是实现时。

AbstractFactory一些优点和缺点：
1）它分离具体的类
2) 它使得易于交换产品系列
3) 它有利于产品的一致性
4) 难 以 支 持 新 种 类 的 产 品

AbstractFactory的结构如下如所示：

AbstractFactory 模式就是用来解决这类问题的:要创建一组相关或者相互依赖的对象

AbstractFactory 模式关键就是将这一组对象的创建封装到一个用于创建对象的类 

AbstractFactory 模式是为创建一组(有多类)相关或依赖的对象提供创建接口,而 Factory 模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到,AbstractFactory 模式通常都是使用 Factory 模式实现

简单的实现代码如下：

1.  /* FileName : Product.h */
2.  
3. #ifndef _PRODUCT_H_
   
4. #define _PRODUCT_H_
   
5. 
   
6. class AbstractProductA
   
7. {
   
8. public:
   
9.      virtual ~AbstractProductA() ;
   
10. protected:
    
11.      AbstractProductA() ;
    
12. } ;
    
13. 
    
14. class AbstractProductB
    
15. {
    
16. public:
    
17.      virtual ~AbstractProductB() ;
    
18. protected:
    
19.      AbstractProductB() ;
    
20. } ;
    
21. 
    
22. class ProductA1 : public AbstractProductA
    
23. {
    
24. public :
    
25.      ProductA1() ;
    
26.      ~ProductA1() ;
    
27. };
    
28. 
    
29. class ProductA2 : public AbstractProductA
    
30. {
    
31. public :
    
32.      ProductA2() ;
    
33.      ~ProductA2() ;
    
34. };
    
35.  
36. class ProductB1 : public AbstractProductB
    
37. {
    
38. public :
    
39.      ProductB1() ;
    
40.      ~ProductB1() ;
    
41. };
    
42. 
    
43. class ProductB2 : public AbstractProductB
    
44. {
    
45. public :
    
46.      ProductB2() ;
    
47.      ~ProductB2() ;
    
48. };
    
49. 
    
50. #endif
    
51.  
52. 
    
53. /* FileName : Product.cpp */
    
54.  
55. #ifndef _PRODUCT_CPP_
    
56. #define _PRODUCT_CPP_
    
57.  
58. #include "Product.h"
    
59. #include <cstdio>
    
60. 
    
61. AbstractProductA::AbstractProductA() {}
    
62. AbstractProductA::~AbstractProductA(){}
    
63. 
    
64. AbstractProductB::AbstractProductB() {}
    
65. AbstractProductB::~AbstractProductB() {}
    
66. 
    
67. ProductA1::ProductA1() {
    
68.     puts( "ProductA1.." ) ;
    
69. }
    
70. ProductA1::~ProductA1() {}
    
71. 
    
72. 
    
73. ProductA2::ProductA2() {
    
74.     puts("ProductA2,," ) ;
    
75. }
    
76. ProductA2::~ProductA2() {}
    
77. 
    
78. ProductB1::ProductB1() {
    
79.     puts( "ProductB1$$" ) ;
    
80. }
    
81. ProductB1::~ProductB1(){}
    
82. 
    
83. ProductB2::ProductB2() {
    
84.     puts("ProductB2**" ) ;
    
85. }
    
86. ProductB2::~ProductB2() {}
    
87. 
    
88. #endif
    
89.   
90. /* FileName : AbstractFactory.h */
    
91. 
    
92. #ifndef _ABSTRACTFACTORY_H_
    
93. #define _ABSTRACTFACTORY_H_
    
94. 
    
95. class AbstractProductA ;
    
96. class AbstractProductB ;
    
97. 
    
98. class AbstractFactory
    
99. {
    
100. public:
     
101.      virtual ~AbstractFactory() ;
     
102.      virtual AbstractProductA* createProductA() = 0 ;
     
103.      virtual AbstractProductB* createProductB() = 0 ;
     
104. 
     
105. protected:
     
106.      AbstractFactory() ;
     
107. } ;
     
108. 
     
109. class concreteFactory1 : public AbstractFactory
     
110. {
     
111. public :
     
112.      concreteFactory1() ;
     
113.      ~concreteFactory1() ;
     
114.      AbstractProductA* createProductA() ;
     
115.      AbstractProductB* createProductB() ;
     
116. } ;
     
117. 
     
118. class concreteFactory2 : public AbstractFactory
     
119. {
     
120. public :
     
121.      concreteFactory2() ;
     
122.      ~concreteFactory2() ;
     
123.      AbstractProductA* createProductA() ;
     
124.      AbstractProductB* createProductB() ;
     
125. } ;
     
126. 
     
127. #endif
     
128. 
     
129.  
130. /* FileName : AbstractFactory.cpp */
     
131.  
132. #ifndef _ABSTRACTFACTORY_CPP_
     
133. #define _ABSTRACTFACTORY_CPP_
     
134. 
     
135. #include "AbstractFactory.h"
     
136. #include "Product.h"
     
137. 
     
138. #include <cstdio>
     
139. 
     
140. AbstractFactory::AbstractFactory(){}
     
141. AbstractFactory::~AbstractFactory() {}
     
142. 
     
143. 
     
144. concreteFactory1::concreteFactory1(){}
     
145. concreteFactory1::~concreteFactory1(){}
     
146. 
     
147. AbstractProductA* concreteFactory1::createProductA()
     
148. {
     
149.     return new ProductA1() ;
     
150. }
     
151. 
     
152. AbstractProductB* concreteFactory1::createProductB()
     
153. {
     
154.     return new ProductB1() ;
     
155. }
     
156. 
     
157. 
     
158. concreteFactory2::concreteFactory2() {}
     
159. concreteFactory2::~concreteFactory2() {}
     
160. 
     
161. AbstractProductA* concreteFactory2::createProductA()
     
162. {
     
163.     return new ProductA2() ;
     
164. }
     
165. 
     
166. AbstractProductB* concreteFactory2::createProductB()
     
167. {
     
168.     return new ProductB2() ;
     
169. }
     
170. 
     
171. #endif
     
172. 
     
173. /*main.cpp*/
174. #include "AbstractFactory.h"
     
175.  
     
176. int main()
     
177. {
     
178.     AbstractFactory* ptr1 = new concreteFactory1() ;
     
179.     ptr1->createProductA() ;
     
180.     ptr1->createProductB() ;
     
181. 
     
182.     AbstractFactory* ptr2 = new concreteFactory2() ;
     
183.     ptr2->createProductA() ;
     
184.     ptr2->createProductB() ;
     
185.     
     
186.     return 0 ; 
     
187. }
     
188. 
     
189. 
     
190. 运行结果如下:
     
191. ProductA1..
     
192. ProductB1$$
     
193. ProductA2,,
     
194. ProductB2**

原文地址:http://www.cnblogs.com/coderlee/archive/2007/12/05/984126.html

                 http://blog.chinaunix.net/uid-26902496-id-3432035.html