Factory
1、定义创建对象的接口,封装对象的创建
2、将实际创建工作延迟到子类中,例如,类A中药使用类B,B是抽象父类,但是在类A中不知道具体要实例化哪一个B的子类,但是在类A的子类D中是可以知道的。在A中无法使用 new B***()方法
3、将创建工作延迟到子类中后,核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂,只提供工厂子类必须实现的接口,这样的好处是可以不用修改已有的工厂类的情况下增加新的产品(每一种产品,都分别对应相应的工厂子类负责其创建工作)
使用场景:用于一类类(所创建的产品继承共同的产品基类)的创建
实现方式1:所谓的工厂方法模式,对每一个子类产品都分别对应一个工厂子类,用来创建相应的产品,这样若增加了新的产品,只需相应增加工厂子类即可
优点:不用修改已有代码,开放封闭原则:对扩展开放,对更改封闭
代码如下:
1 //IHuman.h
2
3 #pragma once
4 class IHuman
5 {
6 public:
7 IHuman(void)
8 {
9 }
10 virtual ~IHuman(void)
11 {
12 }
13 virtual void Laugh() = 0;
14 virtual void Cry() = 0;
15 virtual void Talk() = 0;
16 };
17
18 //YellowHuman.h
19
20 #pragma once
21 #include "ihuman.h"
22 class CYellowHuman :
23 public IHuman
24 {
25 public:
26 CYellowHuman(void);
27 ~CYellowHuman(void);
28 void Laugh();
29 void Cry();
30 void Talk();
31 };
32
33 //YellowHuman.cpp
34
35 #include "StdAfx.h"
36 #include "YellowHuman.h"
37 #include <iostream>
38 using std::cout;
39 using std::endl;
40 CYellowHuman::CYellowHuman(void)
41 {
42 }
43 CYellowHuman::~CYellowHuman(void)
44 {
45 }
46 void CYellowHuman::Cry()
47 {
48 cout << "黄色人种会哭" << endl;
49 }
50 void CYellowHuman::Laugh()
51 {
52 cout << "黄色人种会大笑,幸福呀!" << endl;
53 }
54 void CYellowHuman::Talk()
55 {
56 cout << "黄色人种会说话,一般说的都是双字节" << endl;
57 }
58
59 //WhiteHuman.h
60
61 #pragma once
62 #include "ihuman.h"
63 class CWhiteHuman :
64 public IHuman
65 {
66 public:
67 CWhiteHuman(void);
68 ~CWhiteHuman(void);
69 void Laugh();
70 void Cry();
71 void Talk();
72 };
73
74 //WhiteHuman.cpp
75
76 #include "StdAfx.h"
77 #include "WhiteHuman.h"
78 #include <iostream>
79 using std::cout;
80 using std::endl;
81 CWhiteHuman::CWhiteHuman(void)
82 {
83 }
84 CWhiteHuman::~CWhiteHuman(void)
85 {
86 }
87 void CWhiteHuman::Cry()
88 {
89 cout << "白色人种会哭" << endl;
90 }
91 void CWhiteHuman::Laugh()
92 {
93 cout << "白色人种会大笑,侵略的笑声" << endl;
94 }
95 void CWhiteHuman::Talk()
96 {
97 cout << "白色人种会说话,一般都是单字节" << endl;
98 }
99
100 //BlackHuman.h
101
102 #pragma once
103 #include "ihuman.h"
104 class CBlackHuman :
105 public IHuman
106 {
107 public:
108 CBlackHuman(void);
109 ~CBlackHuman(void);
110 void Laugh();
111 void Cry();
112 void Talk();
113 };
114
115 //BlackHuman.cpp
116
117 #include "StdAfx.h"
118 #include "BlackHuman.h"
119 #include <iostream>
120 using std::cout;
121 using std::endl;
122 CBlackHuman::CBlackHuman(void)
123 {
124 }
125 CBlackHuman::~CBlackHuman(void)
126 {
127 }
128 void CBlackHuman::Cry()
129 {
130 cout << "黑人会哭" << endl;
131 }
132 void CBlackHuman::Laugh()
133 {
134 cout << "黑人会笑" << endl;
135 }
136 void CBlackHuman::Talk()
137 {
138 cout << "黑人可以说话,一般人听不懂" << endl;
139 }
140
141 //IHumanFactory.h
142
143 #pragma once
144 #include "IHuman.h"
145 class IHumanFactory
146 {
147 public:
148 IHumanFactory(void)
149 {
150 }
151 virtual ~IHumanFactory(void)
152 {
153 }
154 virtual IHuman * CreateHuman() = 0;
155 };
156 //YellowHuman.h
157
158 #pragma once
159 #include "ihumanfactory.h"
160 class CYellowHumanFactory :
161 public IHumanFactory
162 {
163 public:
164 CYellowHumanFactory(void);
165 ~CYellowHumanFactory(void);
166 virtual IHuman * CreateHuman(void);
167 };
168
169 //YellowHumanFactory.cpp
170
171 #include "StdAfx.h"
172 #include "YellowHumanFactory.h"
173 #include "YellowHuman.h"
174 CYellowHumanFactory::CYellowHumanFactory(void)
175 {
176 }
177 CYellowHumanFactory::~CYellowHumanFactory(void)
178 {
179 }
180 IHuman * CYellowHumanFactory::CreateHuman( void )
181 {
182 return new CYellowHuman();
183 }
184 //WhiteHuman.h
185
186 #pragma once
187 #include "ihumanfactory.h"
188 class CWhiteHumanFactory :
189 public IHumanFactory
190 {
191 public:
192 CWhiteHumanFactory(void);
193 ~CWhiteHumanFactory(void);
194 virtual IHuman * CreateHuman(void);
195 };
196
197 //WhiteHumanFactory.cpp
198
199 #include "StdAfx.h"
200 #include "WhiteHumanFactory.h"
201 #include "WhiteHuman.h"
202 CWhiteHumanFactory::CWhiteHumanFactory(void)
203 {
204 }
205 CWhiteHumanFactory::~CWhiteHumanFactory(void)
206 {
207 }
208 IHuman * CWhiteHumanFactory::CreateHuman( void )
209 {
210 return new CWhiteHuman();
211 }
212 //BlackHuman.h
213
214 #pragma once
215 #include "ihumanfactory.h"
216 class CBlackHumanFactory :
217 public IHumanFactory
218 {
219 public:
220 CBlackHumanFactory(void);
221 ~CBlackHumanFactory(void);
222 virtual IHuman * CreateHuman();
223 };
224 //BlackHumanFactory.cpp
225
226 #include "StdAfx.h"
227 #include "BlackHumanFactory.h"
228 #include "BlackHuman.h"
229 CBlackHumanFactory::CBlackHumanFactory(void)
230 {
231 }
232 CBlackHumanFactory::~CBlackHumanFactory(void)
233 {
234 }
235 IHuman * CBlackHumanFactory::CreateHuman()
236 {
237 return new CBlackHuman();
238 }
239
240 //FactoryMethod.cpp
241
242 // FactoryMethod.cpp : 定义控制台应用程序的入口点。
243 //
244 #include "stdafx.h"
245 #include "IHuman.h"
246 #include "YellowHuman.h"
247 #include "WhiteHuman.h"
248 #include "BlackHuman.h"
249 #include "SimpleHumanFactory.h"
250 #include "StandardHumanFactory.h"
251 #include "IHumanFactory.h"
252 #include "YellowHumanFactory.h"
253 #include "WhiteHumanFactory.h"
254 #include "BlackHumanFactory.h"
255 #include <iostream>
256 using std::cout;
257 using std::endl;
258 using std::string;
259 void DoFactoryMethod1()
260 {
261 cout << "----------第一批人是这样的:黄种人工厂来生产黄种人" << endl;
262 IHumanFactory *pHumanFactory = new CYellowHumanFactory();
263 IHuman *pHuman = pHumanFactory->CreateHuman();
264 pHuman->Cry();
265 pHuman->Laugh();
266 pHuman->Talk();
267 delete pHuman;
268 delete pHumanFactory;
269 }
270 void DoFactoryMethod2()
271 {
272 cout << "----------第二批人是这样的:白种人工厂来生产白种人" << endl;
273 IHumanFactory *pHumanFactory = new CWhiteHumanFactory();
274 IHuman *pHuman = pHumanFactory->CreateHuman();
275 pHuman->Cry();
276 pHuman->Laugh();
277 pHuman->Talk();
278 delete pHuman;
279 delete pHumanFactory;
280 }
281 void DoFactoryMethod3()
282 {
283 cout << "----------第一批人是这样的:黑种人工厂来生产黑种人" << endl;
284 IHumanFactory *pHumanFactory = new CBlackHumanFactory();
285 IHuman *pHuman = pHumanFactory->CreateHuman();
286 pHuman->Cry();
287 pHuman->Laugh();
288 pHuman->Talk();
289 delete pHuman;
290 delete pHumanFactory;
291 }
292 int _tmain(int argc, _TCHAR* argv[])
293 {
294 //工厂方法
295 cout << "----------工厂方法:" << endl;
296 DoFactoryMethod1();
297 DoFactoryMethod2();
298 DoFactoryMethod3();
299
300 _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
301 _CrtDumpMemoryLeaks();
302 return 0;
303 }
View Code
实现方式2:所谓的简单工厂模式,通过参数传递来决定要创建哪一个具体产品。
若不需延迟实例化(将实例化放到子类中),则在Factory中增加对应的创建方法即可,如:Product* CreateConcreteProduct(int i);
若需要延迟实例化,则在抽象Factory与具体ConcreteFactory中增加相应方法,在ConcreteFactory中实现方法Product* CreateConcreteProduct(int i)
优点:无需新增产品工厂类ConcreteFactory
缺点:需要修改已有代码,存在风险
代码如下:
1 //Product.h
2 // Product.h: interface for the Product class.
3 //
4 //////////////////////////////////////////////////////////////////////
5
6 #if !defined(AFX_PRODUCT_H__714E1D10_AFA3_473E_A16C_759490E60B92__INCLUDED_)
7 #define AFX_PRODUCT_H__714E1D10_AFA3_473E_A16C_759490E60B92__INCLUDED_
8
9 #if _MSC_VER > 1000
10 #pragma once
11 #endif // _MSC_VER > 1000
12
13 class Product
14 {
15 public:
16 Product();
17 virtual ~Product();
18
19 };
20
21 class ConcreteProduct : public Product
22 {
23 public:
24 ConcreteProduct();
25 virtual ~ConcreteProduct();
26
27 };
28
29 class ConcreteProduct1 : public Product
30 {
31 public:
32 ConcreteProduct1();
33 virtual ~ConcreteProduct1();
34
35 };
36
37 #endif // !defined(AFX_PRODUCT_H__714E1D10_AFA3_473E_A16C_759490E60B92__INCLUDED_)
38
39
40
41 //Product.cpp
42 // Product.cpp: implementation of the Product class.
43 //
44 //////////////////////////////////////////////////////////////////////
45
46 #include "Product.h"
47 #include <iostream>
48
49 using namespace std;
50
51 //////////////////////////////////////////////////////////////////////
52 // Construction/Destruction
53 //////////////////////////////////////////////////////////////////////
54
55 Product::Product()
56 {
57 }
58
59 Product::~Product()
60 {
61 }
62
63 ConcreteProduct::ConcreteProduct()
64 {
65 cout<<"ConcreteProduct..."<<endl;
66 }
67
68 ConcreteProduct::~ConcreteProduct()
69 {
70 }
71
72 ConcreteProduct1::ConcreteProduct1()
73 {
74 cout<<"ConcreteProduct1..."<<endl;
75 }
76
77 ConcreteProduct1::~ConcreteProduct1()
78 {
79 }
80
81
82 //Factory.h
83
84 #if !defined(AFX_FACTORY_H__32B11FEA_57A7_484E_B289_AB0E12783D7D__INCLUDED_)
85 #define AFX_FACTORY_H__32B11FEA_57A7_484E_B289_AB0E12783D7D__INCLUDED_
86
87 #if _MSC_VER > 1000
88 #pragma once
89 #endif // _MSC_VER > 1000
90
91 class Product;
92 class Factory
93 {
94 public:
95 virtual Product* CreateConcreteProduct(int i)=0;
96 Factory();
97 virtual ~Factory() = 0;
98 virtual Product* CreateProduct() = 0;
99 virtual Product* CreateProduct1() = 0;
100 };
101
102 class ConcreteFactory : public Factory
103 {
104 public:
105 ConcreteFactory();
106 virtual ~ConcreteFactory();
107 virtual Product* CreateProduct();
108 virtual Product* CreateProduct1();
109 virtual Product* CreateConcreteProduct(int i);
110 };
111
112 #endif // !defined(AFX_FACTORY_H__32B11FEA_57A7_484E_B289_AB0E12783D7D__INCLUDED_)
113
114
115 //Factory.cpp
116
117 // Factory.cpp: implementation of the Factory class.
118 //
119 //////////////////////////////////////////////////////////////////////
120
121 #include "Factory.h"
122 #include "Product.h"
123 #include <iostream>
124
125 using namespace std;
126
127 //////////////////////////////////////////////////////////////////////
128 // Construction/Destruction
129 //////////////////////////////////////////////////////////////////////
130
131 Factory::Factory()
132 {
133 }
134
135 Factory::~Factory()
136 {
137 }
138
139 ConcreteFactory::ConcreteFactory()
140 {
141 cout<<"ConcreteFactory..."<<endl;
142 }
143
144 ConcreteFactory::~ConcreteFactory()
145 {
146 }
147
148 Product* ConcreteFactory::CreateProduct()
149 {
150 return new ConcreteProduct();
151 }
152
153 Product* ConcreteFactory::CreateProduct1()
154 {
155 return new ConcreteProduct1();
156 }
157
158
159 Product* ConcreteFactory::CreateConcreteProduct(int i)
160 {
161 Product* pProduct = NULL;
162 switch(i)
163 {
164 case 0:
165 pProduct = new ConcreteProduct();
166 break;
167 case 1:
168 pProduct = new ConcreteProduct1();
169 break;
170 default:
171 break;
172 }
173 return pProduct;
174 }
175
176 //main.cpp
177 #include "Factory.h"
178 #include "Product.h"
179 #include <iostream>
180
181 using namespace std;
182
183 int main()
184 {
185 Factory* pFactory = new ConcreteFactory();
186
187 Product* pProduct = pFactory->CreateProduct1();
188
189 //Product* pProduct = pFactory->CreateConcreteProduct(1);
190 return 0;
191 }
View Code
若要为不同类的类提供一个创建对象的接口,要用AbstractFactory。
工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。
工厂模式可以分为三类:
1)简单工厂模式(Simple Factory)
2)工厂方法模式(Factory Method)
3)抽象工厂模式(Abstract Factory)
这三种模式从上到下逐步抽象,并且更具一般性。
GOF在《设计模式》一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory)。将简单工厂模式(Simple Factory)看为工厂方法模式的一种特例,两者归为一类。
区别
工厂方法模式:
一个抽象产品类,可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式:
多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别:
工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。
两者皆可。
原文链接: https://www.cnblogs.com/jiese/p/3154669.html
欢迎关注
微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍
原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/93347
非原创文章文中已经注明原地址,如有侵权,联系删除
关注公众号【高性能架构探索】,第一时间获取最新文章
转载文章受原作者版权保护。转载请注明原作者出处!