注：
文档内容基本上来自于网上，并加上自己的理解而成。有的觉得网友总结得非常好，就完全照搬下来，供学习之用。然而，有的摘抄并没有加上原链接和出处，请谅解。
Abstract Factory模式强调的是系列产品的替换，或者说系列产品的创建。 抽像工厂和一般的工厂各有优缺点：
对于，普通工厂来说，我们是可以扩展产品的（Product和Product Factory），但是对于产生产品系列来说非常麻烦，会导致工厂泛滥。
对对，抽像工厂来说，对于产生产品系统非常方便，但对于产生产品品种来说，需要改动的地方比较多。
（现在并没有兼具普通工厂和抽像工厂的解决方案） Spring提供了一个简单的解决方案：BeanFactory
\\
Abstract Factory模式（抽象工厂模式）
（参考自：http://blog.csdn.net/woods2001/article/details/6655083）
抽象工厂，是简单工厂和工厂方法的升级版。相比这两个模式，抽象工
厂有这更大的灵活性，同时也更加复杂一些。
抽象工厂模式的实质是“提供接口，创建一系列相关或独立的对象，而不指定这些对象的具体类。”[1]
结构
理解
1. AbstractFactory是抽象工厂类，声明创建产品族的接口。具体工厂创建具体的产品族（Product Family），可以创建出分属于不同产品等级的一个产品族中的所有对象。ConcreteFactory1和ConcreteFactory2分别生产2个不同产品族。（比如游戏关卡里同一级别的不同怪物??）
举例：手机工厂生产的产品族中，产品有Linux系统的手机和Windows系统的手机。PC工厂生产的产品族中，产品有Linux系统的PC和Windows系统的PC。(两个产品族：手机产品族和PC产品族)
2. AbstractProductA和AbstractProductB是产品基类。它们的派生类是同产品等级结构（产品类型）的具的体产品。
举例：Linux的具体产品类型包括Linux手机版和Linux PC版，Windows的具体产品类型包括Windows手机版和Windows PC版。 产品族和产品等级的关系：
从上图可以看出，4个具体工厂，每个产品族有3个不同类型的产品，可以生产具体产品4*3=12中具体产品。而对于工厂方法模式，生产12中产品，需要有12个工厂。 3. 调用者（Client）只能看到抽象层次接口。 要点
1. 抽象工厂应用场景：
一个系统要独立于它的产品的创建、组合和表示时。 一个系统要由多个产品系列中的一个来配置时。
当你要强调一系列相关的产品对象的设计以便进行联合使用时。 当你提供一个产品类库，而只想显示它们的接口而不是实现时。
2. 新增产品复杂。抽象工厂增加产品组件时，需要更改所有工厂的接口。如增加产品ProductC，则工厂基类和具体工厂需要增加接口CreateProductC。 3. 抽象工厂模式与工厂方法模式的区别。
a． 重点不同。工厂方法模式强调的是不同的创建者根据自身需求去生产不同的具体产品，重点是生产具体产品；而抽象工厂模式则定位为“在不指定实体类别的前提下，提供了一个可以创建一系列相关或互相依赖之组件的接口”，重点是创建相关组件。
b． 抽象工厂提供了的“相关组件”可以看成是具体的产品（如ProductA1），抽象工厂模式的“相关组件”可由工厂模式实现。ConcreteFactory1.CreateProuductA()生产的具体产品，可以用工厂方法模式实现，即每一个产品用一个工厂方法实现。
c． 工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
d． 抽象工厂不能直接创建产品，只能创建工厂，即抽象工厂创建的产品是工厂。虽然它也定义了创建产品的方法，但需要创建出来的具体的工厂实现，即抽象工厂创建出的工厂创建产品。
e． 工厂方法采用的是类继承机制（生成一个子类，重写该工厂方法，在该方法中生产一个对象）；而抽象工厂采用的是对象组合机制，专门定义“工厂”对象来负责对象的创建。对象组合的方式就是把“工厂”对象作为参数传递。 应用
抽象工厂模式可应用：支持多种数据库的数据库接口访问层；界面设计各种风格界面等。 源码中通过PC工厂和手机工厂和预装的操作系统产品来举例实现模式。
源码
#include
/////////////产品 class CLinux { public:
virtual ~CLinux() {}; //产品使用公共接口
virtual void Start() = 0; };
class CLinuxMobile : public CLinux { public:
CLinuxMobile() {
cout << \ << endl; }
virtual ~CLinuxMobile() {}; virtual void Start() {
cout << \ << endl; }; };
class CLinuxPC : public CLinux { public: CLinuxPC() {
cout << \ << endl; }
virtual ~CLinuxPC() {}; virtual void Start() {
cout << \ << endl; };
};
class CWindows { public:
virtual ~CWindows() {}; //产品使用公共接口
virtual void Start() = 0; };
class CWindowsMobile : public CWindows { public:
CWindowsMobile() {
cout << \ << endl; }
virtual ~CWindowsMobile() {}; virtual void Start() {
cout << \ << endl; }; };
class CWindowsPC : public CWindows { public:
CWindowsPC() {
cout << \ << endl; }
virtual ~CWindowsPC() {}; virtual void Start() {
cout << \ << endl; }; }; ////工厂 class CFactory { public:
virtual ~CFactory(){}; //产品族有个产品组件
virtual CLinux* CreateLinux() = 0; virtual CWindows* CreateWindows() = 0; };
class CMobileFactory : public CFactory
{ public:
CMobileFactory() {
cout << \ << endl; }
virtual ~CMobileFactory(){}; virtual CLinux* CreateLinux() {
return new CLinuxMobile; };
virtual CWindows* CreateWindows() {
return new CWindowsMobile; }; };
class CPCFactory : public CFactory { public:
CPCFactory() {
cout << \ << endl; }
virtual ~CPCFactory(){}; virtual CLinux* CreateLinux() {
return new CLinuxPC; };
virtual CWindows* CreateWindows() {
return new CWindowsPC; }; };
void Test(CFactory* pFactory) {
CLinux* pLinux = NULL; CWindows* pWindows = NULL; pLinux = pFactory->CreateLinux(); pWindows = pFactory->CreateWindows(); pLinux->Start(); pWindows->Start(); delete pWindows; delete pLinux; };
int main() {
CFactory* pFactory = NULL;
//手机工厂。生产手机产品族，种类有Linux和Windows pFactory = new CMobileFactory; Test(pFactory); delete pFactory; cout << endl;
//PC工厂。生产PC产品族，种类有Linux和Windows pFactory= new CPCFactory; Test(pFactory); delete pFactory;
system(\); return 0; } 输出：
create mobile factory. create linux mobile. create windows mobile. linux mobile start. windows mobile start.
create PC factory. create linux PC. create windows PC. linux PC start. windows PC start.
为了方便理解，下面再举一个例子
(参考自：
http://www.cppblog.com/emptysoul/archive/2009/02/23/73176.html?opt=admin) 我们现在要生产电脑产品，假设电脑产品现在只有台式机及笔记本两种，我们需要建一个工厂用来生产电脑产品，而工厂中可以生产不同品牌的电脑，对于每个品牌，我们分别建立相应的品牌工厂，负责生产各自的品牌产品，假设现在有DELL及IBM两个品牌工厂，那么现在每个工厂都可以生产各自的台式机及笔记本了。 其类图如下：
以下是实现代码：
//DesktopProduct.h class DesktopProduct {
public:
virtual ~DesktopProduct(); protected:
DesktopProduct(); };
//DesktopProduct.cpp #include \
#include \
DesktopProduct::DesktopProduct() { }
DesktopProduct::~DesktopProduct() { }
//DELLDesktopProduct.h
#include \
class DELLDesktopProduct : public DesktopProduct {
public:
DELLDesktopProduct();
virtual ~DELLDesktopProduct();
};
//DELLDesktopProduct.cpp #include \
#include \#include
using namespace std;
DELLDesktopProduct::DELLDesktopProduct() {
cout << \创建DELL台式机\}
DELLDesktopProduct::~DELLDesktopProduct() { }
//IBMDesktopProduct.h
#include \
class IBMDesktopProduct : public DesktopProduct {
public:
IBMDesktopProduct();
virtual ~IBMDesktopProduct(); };
//IBMDesktopProduct.cpp #include \
#include \#include
using namespace std;
IBMDesktopProduct::IBMDesktopProduct() {
cout << \创建IBM台式机\}
IBMDesktopProduct::~IBMDesktopProduct() { }
//NotebookProduct.h class NotebookProduct {
public:
virtual ~NotebookProduct(); protected:
NotebookProduct(); };
//NotebookProduct.cpp #include \
#include \
NotebookProduct::NotebookProduct() {
}
NotebookProduct::~NotebookProduct() { }
//DELLNotebookProduct.h
#include \
class DELLNotebookProduct : public NotebookProduct {
public:
DELLNotebookProduct();
virtual ~DELLNotebookProduct(); };
//DELLNotebookProduct.cpp #include \
#include \#include
using namespace std;
DELLNotebookProduct::DELLNotebookProduct() {
cout << \创建DELL笔记本\}
DELLNotebookProduct::~DELLNotebookProduct() { }
//IBMNotebookProduct.h
#include \
class IBMNotebookProduct : public NotebookProduct {
public:
IBMNotebookProduct();
virtual ~IBMNotebookProduct(); };
//IBMNotebookProduct.cpp using namespace std;
IBMNotebookProduct::IBMNotebookProduct() {
cout << \创建IBM笔记本\}
IBMNotebookProduct::~IBMNotebookProduct() { }
//AbstractFactory.h class DesktopProduct; class NotebookProduct; class AbstractFactory
{
public:
virtual ~AbstractFactory();
virtual DesktopProduct* CreateDesktopProduct() = 0; virtual NotebookProduct* CreateNotebookProduct() = 0; protected:
AbstractFactory(); };
//AbstractFactory.cpp #include \
#include \
AbstractFactory::AbstractFactory() { }
AbstractFactory::~AbstractFactory() { }
//DELLFactory.h
#include \
class DELLFactory : public AbstractFactory {
public:
DELLFactory();
virtual ~DELLFactory();
DesktopProduct* CreateDesktopProduct(); NotebookProduct* CreateNotebookProduct(); };
//DELLFactory.cpp #include \
#include \
#include \#include \
DELLFactory::DELLFactory() { }
DELLFactory::~DELLFactory() { }
DesktopProduct* DELLFactory::CreateDesktopProduct() {
return new DELLDesktopProduct; }
NotebookProduct* DELLFactory::CreateNotebookProduct() {
return new DELLNotebookProduct; }
//IBMFactory.h
#include \
class IBMFactory : public AbstractFactory {
public:
IBMFactory();
virtual ~IBMFactory();
DesktopProduct* CreateDesktopProduct(); NotebookProduct* CreateNotebookProduct(); };
//IBMFactory.cpp #include \
#include \
#include \#include \
IBMFactory::IBMFactory() { }
IBMFactory::~IBMFactory() { }
DesktopProduct* IBMFactory::CreateDesktopProduct() {
return new IBMDesktopProduct; }
NotebookProduct* IBMFactory::CreateNotebookProduct() {
return new IBMNotebookProduct; }
//Main.cpp
#include \
#include \#include \#include \
#include \#include \#include \#include \
#include \#include \
int main(int argc, char* argv[]) {
AbstractFactory* fac = new DELLFactory(); fac->CreateDesktopProduct(); fac->CreateNotebookProduct(); delete fac;
fac = new IBMFactory();
fac->CreateDesktopProduct(); fac->CreateNotebookProduct(); delete fac;
return 0; }
最后输出为： 创建DELL台式机 创建DELL笔记本 创建IBM台式机 创建IBM笔记本