设计模式的目的就是尽量减少“变化”对程序的影响，尤其是对客户程序的影响。AbstractFactory模式作为创建型模式的一种，解决的就是“new”在变化中可能引起的问题。
先来看看new有何种不好，举个创建汽车的车门的例子：
很自然的一种想法是：Door *door = new Door();
但是如果遇到创建老爷车的车门，创建现代车的车门，这段代码就无所适从了。
OO为我们提供了哪些精华的思想？“封装”，是的，将车门的创建封装起来，于是我们有了静态工厂方法：
客户程序代码：
Door* door = doorFactory->CreateDoor();
库程序代码：
class DoorFactory2
{3
public:4
Door* CreateDoor()5
{6
return new Door();7
}8
}
客户程序在此是不会变化的，不管你是老爷车门，现代车门，还是钻石车门，这些和客户程序代码都是没关系的，究竟CreateDoor出来如何结果都交给多态来判断，我们不用操心。
但是库程序代码还是需要更改的，但我们已经将“变化”与客户程序隔离了。
需求又有变化了，不光要创建车门，还需要创建引擎，车灯，而且还是不同风格的。
这时候静态工厂已经应付不来了，静态工厂有其自身的缺陷“不能应对不同系列对象”的变化。
动机：
软件系统中，经常面临“一系列相互依赖的对象”的创建工作。（两个特征：“一系列”，“相互依赖”）
将创建过程封装起来，避免“客户程序”和“多系列具体对象的创建工作”的紧耦合。
意图：
提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定他们具体的类。（GoF23）
思路：
对于客户程序来说，只依赖于三个抽象的类：AbstractFactory，AbstractProductA，AbstractProductB。
以下是客户程序代码：
class CarManager2
{3
protected:4
AbstractFactory *abstractFactory;5
public:6
//创造Car7
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 Test3
//4
//5
6
#include "stdafx.h"7
#include "iostream"8
using namespace std;9
10
//Engine,Door,Light are the Abstract Product11
//这三个类对应UML图中的AbstractProduct类12
class Engine13
{14
public:15
Engine()16
{17
cout<<"Abstract Engine Create"<<endl;18
}19
virtual void doSomething() = 0;20
};21
22
class Door23
{24
public:25
Door()26
{27
cout<<"Abstract Door Create"<<endl;28
}29
virtual void doSomething() = 0;30
};31
32
class Light33
{34
public:35
Light()36
{37
cout<<"Abstract Light Create"<<endl;38
}39
virtual void doSomething() = 0;40
};41
42
//Abstract Factory43
class AbstractFactory44
{45
public: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 Engine58
{59
public :60
SpeedEngine()61
{62
cout<<"Speed Engine Create"<<endl;63
}64
void doSomething(){ }65
};66
67
class SpeedDoor:public Door68
{69
public :70
SpeedDoor()71
{72
cout<<"Speed Door Create"<<endl;73
}74
void doSomething(){ }75
};76
77
class SpeedLight:public Light78
{79
public :80
SpeedLight()81
{82
cout<<"Speed Light Create"<<endl;83
}84
void doSomething(){ }85
};86
87
//classicEngine,classicDoor,classicLight are the products of Classic style88
//这三个类对应UML图中的ProductA2，ProductB2，ProductC2类89
class ClassicEngine:public Engine90
{91
public :92
ClassicEngine()93
{94
cout<<"Classic Engine Create"<<endl;95
}96
void doSomething(){ }97
};98
99
class ClassicDoor:public Door100
{101
public :102
ClassicDoor()103
{104
cout<<"Classic Door Create"<<endl;105
}106
void doSomething(){ }107
};108
109
class ClassicLight:public Light110
{111
public :112
ClassicLight()113
{114
cout<<"Classic Light Create"<<endl;115
}116
void doSomething(){ }117
};118
119
//Factory for Speed Cars120
//对应UML图中的ConcreteFactory1类121
class SpeedFactory:public AbstractFactory122
{123
public: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 Cars143
//对应UML图中的ConcreteFactory2类144
class ClassicFactory:public AbstractFactory145
{146
public: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 car166
//this is never changed167
class CarManager168
{169
protected:170
AbstractFactory *abstractFactory;171
public:172
//创造Car173
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
}
