设计模式的目的就是尽量减少“变化”对程序的影响，尤其是对客户程序的影响。AbstractFactory模式作为创建型模式的一种，解决的就是“new”在变化中可能引起的问题。
先来看看new有何种不好，举个创建汽车的车门的例子：
很自然的一种想法是：Door *door = new Door();
但是如果遇到创建老爷车的车门，创建现代车的车门，这段代码就无所适从了。
OO为我们提供了哪些精华的思想？“封装”，是的，将车门的创建封装起来，于是我们有了静态工厂方法：
客户程序代码：
1
Door* door = doorFactory->CreateDoor();
库程序代码：
1class DoorFactory
2
{
3
public:
4 Door* CreateDoor()
5
{
6 return new Door();
7
}
8
}
客户程序在此是不会变化的，不管你是老爷车门，现代车门，还是钻石车门，这些和客户程序代码都是没关系的，究竟CreateDoor出来如何结果都交给多态来判断，我们不用操心。
但是库程序代码还是需要更改的，但我们已经将“变化”与客户程序隔离了。
需求又有变化了，不光要创建车门，还需要创建引擎，车灯，而且还是不同风格的。
这时候静态工厂已经应付不来了，静态工厂有其自身的缺陷“不能应对不同系列对象”的变化。
动机：
软件系统中，经常面临“一系列相互依赖的对象”的创建工作。（两个特征：“一系列”，“相互依赖”）
将创建过程封装起来，避免“客户程序”和“多系列具体对象的创建工作”的紧耦合。
意图：
提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定他们具体的类。（GoF23）
思路：
对于客户程序来说，只依赖于三个抽象的类：AbstractFactory，AbstractProductA，AbstractProductB。
以下是客户程序代码：
1class CarManager
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
17int _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模式主要针对“风格”的变化，如果“对象”本身经常变化，那么该模式并不适用。
自己做的示例代码，仅供参考
1/**/////////////////////////////////////////////////////////////////////////// 2// AbstractFactoryTest for AbstractFactory Pattern Test
3//
4/**/////////////////////////////////////////////////////////////////////////// 5
6#include "stdafx.h"
7#include "iostream"
8using namespace std;
9
10//Engine,Door,Light are the Abstract Product
11//这三个类对应UML图中的AbstractProduct类
12class Engine
13{
14public:
15 Engine()
16 {
17 cout<<"Abstract Engine Create"<<endl;
18 }
19 virtual void doSomething() = 0;
20};
21
22class Door
23{
24public:
25 Door()
26 {
27 cout<<"Abstract Door Create"<<endl;
28 }
29 virtual void doSomething() = 0;
30};
31
32class Light
33{
34public:
35 Light()
36 {
37 cout<<"Abstract Light Create"<<endl;
38 }
39 virtual void doSomething() = 0;
40};
41
42//Abstract Factory
43class 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类
57class SpeedEngine:public Engine
58{
59public :
60 SpeedEngine()
61 {
62 cout<<"Speed Engine Create"<<endl;
63 }
64 void doSomething(){ }
65};
66
67class SpeedDoor:public Door
68{
69public :
70 SpeedDoor()
71 {
72 cout<<"Speed Door Create"<<endl;
73 }
74 void doSomething(){ }
75};
76
77class 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类
89class ClassicEngine:public Engine
90{
91public :
92 ClassicEngine()
93 {
94 cout<<"Classic Engine Create"<<endl;
95 }
96 void doSomething(){ }
97};
98
99class ClassicDoor:public Door
100{
101public :
102 ClassicDoor()
103 {
104 cout<<"Classic Door Create"<<endl;
105 }
106 void doSomething(){ }
107};
108
109class 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类
121class 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类
144class 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
167class 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
183int _tmain(int argc, _TCHAR* argv[])
184{
185 CarManager *carManager = new CarManager();
186 //创建Classic风格的汽车
187 carManager->createCar(new ClassicFactory());
188
189 return 0;
190}