设计模式的目的就是尽量减少“变化”对程序的影响,尤其是对客户程序的影响。AbstractFactory模式作为创建型模式的一种,解决的就是“new”在变化中可能引起的问题。
先来看看new有何种不好,举个创建汽车的车门的例子:
很自然的一种想法是:Door *door = new Door();
但是如果遇到创建老爷车的车门,创建现代车的车门,这段代码就无所适从了。
OO为我们提供了哪些精华的思想?“封装”,是的,将车门的创建封装起来,于是我们有了静态工厂方法:
客户程序代码:
库程序代码:
2 {
3public:
4 Door* CreateDoor()
5 {
6 return new Door();
7 }
8}
客户程序在此是不会变化的,不管你是老爷车门,现代车门,还是钻石车门,这些和客户程序代码都是没关系的,究竟CreateDoor出来如何结果都交给多态来判断,我们不用操心。
但是库程序代码还是需要更改的,但我们已经将“变化”与客户程序隔离了。
需求又有变化了,不光要创建车门,还需要创建引擎,车灯,而且还是不同风格的。
这时候静态工厂已经应付不来了,静态工厂有其自身的缺陷“不能应对不同系列对象”的变化。
动机:
软件系统中,经常面临“一系列相互依赖的对象”的创建工作。(两个特征:“一系列”,“相互依赖”)
将创建过程封装起来,避免“客户程序”和“多系列具体对象的创建工作”的紧耦合。
意图:
提供一个接口,让该接口负责创建一系列“相关或者相互依赖的对象”,无需指定他们具体的类。(GoF23)
思路:
对于客户程序来说,只依赖于三个抽象的类:AbstractFactory,AbstractProductA,AbstractProductB。
以下是客户程序代码:
2 {
3protected:
4 AbstractFactory *abstractFactory;
5public:
6 //创造Car
7 void createCar(AbstractFactory *abstractFactory)
8 {
9 abstractFactory->CreateEngine();
10 abstractFactory->CreateDoor();
11 abstractFactory->CreateLight();
12 }
13 //其他的操作
14 void run(){}
15} ;
16
17 int _tmain( int argc, _TCHAR * argv[])
18 {
19 CarManager *carManager = new CarManager();
20 //创建Classic风格的汽车
21 carManager->createCar(new ClassicFactory());
22
23 return 0;
24}
所有关于创建的操作都是用抽象类完成的,对于具体是何种类型的对象由多态实现,以此来使“客户代码”和“多系列具体对象的创建工作”达到松耦合。
如果遇到还需要扩展其他风格的汽车,可以按下图的思路
红色的部分对应新风格的车辆,只需在库程序中添加ConcreteFactory3,ProductA3,ProductB3三个类,而对于客户代码CarManager来说完全不受影响。
总结:
AbstractFactory模式有以下三个要点:
1.应对的问题是“多风格的系列对象创建”的变化问题,“系列对象”指的是这些对象之间有相互依赖或者相互作用的关系。否则使用“静态工厂”足以。
2.抽象工厂和静态工厂的核心是“封装”,将对象的创建进行封装,避免“new”引起的问题
3.抽象工程的另一个核心是“多态”,通过动态绑定来处理“不同风格”的问题
注:
AbstractFactory模式主要针对“风格”的变化,如果“对象”本身经常变化,那么该模式并不适用。
自己做的示例代码,仅供参考
2 // AbstractFactoryTest for AbstractFactory Pattern Test
3 //
4 //
5
6 #include " stdafx.h "
7 #include " iostream "
8 using namespace std;
9
10 // Engine,Door,Light are the Abstract Product
11 // 这三个类对应UML图中的AbstractProduct类
12 class Engine
13 {
14public:
15 Engine()
16 {
17 cout<<"Abstract Engine Create"<<endl;
18 }
19 virtual void doSomething() = 0;
20} ;
21
22 class Door
23 {
24public:
25 Door()
26 {
27 cout<<"Abstract Door Create"<<endl;
28 }
29 virtual void doSomething() = 0;
30} ;
31
32 class Light
33 {
34public:
35 Light()
36 {
37 cout<<"Abstract Light Create"<<endl;
38 }
39 virtual void doSomething() = 0;
40} ;
41
42 // Abstract Factory
43 class AbstractFactory
44 {
45public:
46 AbstractFactory()
47 {
48 cout<<"AbstractFactory Create"<<endl;
49 }
50 virtual Engine* CreateEngine() = 0;
51 virtual Door* CreateDoor() = 0;
52 virtual Light* CreateLight() = 0;
53} ;
54
55 // SpeedEngine,SpeedDoor,SpeedLight are the Products of Speed Style
56 // 这三个类对应UML图中的ProductA1,ProductB1,ProductC1类
57 class SpeedEngine: public Engine
58 {
59public :
60 SpeedEngine()
61 {
62 cout<<"Speed Engine Create"<<endl;
63 }
64 void doSomething(){ }
65} ;
66
67 class SpeedDoor: public Door
68 {
69public :
70 SpeedDoor()
71 {
72 cout<<"Speed Door Create"<<endl;
73 }
74 void doSomething(){ }
75} ;
76
77 class SpeedLight: public Light
78 {
79public :
80 SpeedLight()
81 {
82 cout<<"Speed Light Create"<<endl;
83 }
84 void doSomething(){ }
85} ;
86
87 // classicEngine,classicDoor,classicLight are the products of Classic style
88 // 这三个类对应UML图中的ProductA2,ProductB2,ProductC2类
89 class ClassicEngine: public Engine
90 {
91public :
92 ClassicEngine()
93 {
94 cout<<"Classic Engine Create"<<endl;
95 }
96 void doSomething(){ }
97} ;
98
99 class ClassicDoor: public Door
100 {
101public :
102 ClassicDoor()
103 {
104 cout<<"Classic Door Create"<<endl;
105 }
106 void doSomething(){ }
107} ;
108
109 class ClassicLight: public Light
110 {
111public :
112 ClassicLight()
113 {
114 cout<<"Classic Light Create"<<endl;
115 }
116 void doSomething(){ }
117} ;
118
119 // Factory for Speed Cars
120 // 对应UML图中的ConcreteFactory1类
121 class SpeedFactory: public AbstractFactory
122 {
123public:
124 SpeedFactory()
125 {
126 cout<<"SpeedFactory Create"<<endl;
127 }
128 virtual Engine* CreateEngine()
129 {
130 return new SpeedEngine();
131 }
132 virtual Door* CreateDoor()
133 {
134 return new SpeedDoor();
135 }
136 virtual Light* CreateLight()
137 {
138 return new SpeedLight();
139 }
140} ;
141
142 // Factory for classic Cars
143 // 对应UML图中的ConcreteFactory2类
144 class ClassicFactory: public AbstractFactory
145 {
146public:
147 ClassicFactory()
148 {
149 cout<<"ClassicFactory Create"<<endl;
150 }
151 virtual Engine* CreateEngine()
152 {
153 return new ClassicEngine();
154 }
155 virtual Door* CreateDoor()
156 {
157 return new ClassicDoor();
158 }
159 virtual Light* CreateLight()
160 {
161 return new ClassicLight();
162 }
163} ;
164
165 // Client Code ---- use the Abstract Factory & Abstract Product to create the car
166 // this is never changed
167 class CarManager
168 {
169protected:
170 AbstractFactory *abstractFactory;
171public:
172 //创造Car
173 void createCar(AbstractFactory *abstractFactory)
174 {
175 abstractFactory->CreateEngine();
176 abstractFactory->CreateDoor();
177 abstractFactory->CreateLight();
178 }
179 //其他的操作
180 void run(){}
181} ;
182
183 int _tmain( int argc, _TCHAR * argv[])
184 {
185 CarManager *carManager = new CarManager();
186 //创建Classic风格的汽车
187 carManager->createCar(new ClassicFactory());
188
189 return 0;
190}