设计模式之抽象工厂模式（AbstactFactory ）
概念
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
介绍
意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
主要解决：主要解决接口选择的问题。
何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
如何解决：在一个产品族里面，定义多个产品。
关键代码：在一个工厂里聚合多个同类产品。
优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
注意事项：产品族难扩展，产品等级易扩展。
模式结构
AbstractFactory 模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中， 维护这样一个创建类总比维护 n 多相关对象的创建过程要简单的多。
代码实现
“Product.h”
#ifndef _PRODUCT_H
#define _PRODUCT_H
class AbstractProductA{
public:
virtual ~AbstractProductA();
protected:
AbstractProductA();
};
class AbstractProductB{
public:
virtual ~AbstractProductB();
protected:
AbstractProductB();
};
class ProductA1:public AbstractProductA{
public:
ProductA1();
~ProductA1();
};
class ProductA2 :public AbstractProductA{
public:
ProductA2();
~ProductA2();
};
class ProductB1 :public AbstractProductB{
public:
ProductB1();
~ProductB1();
};
class ProductB2 :public AbstractProductB{
public:
ProductB2();
~ProductB2();
};
#endif“Product.cpp”
#include<iostream>
#include"Product.h"
using namespace std;
AbstractProductA::AbstractProductA(){}
AbstractProductA::~AbstractProductA(){}
AbstractProductB::AbstractProductB(){}
AbstractProductB::~AbstractProductB(){}
ProductA1::ProductA1(){
cout << "ProductA1" << endl;
}
ProductA1::~ProductA1(){}
ProductA2::ProductA2(){
cout << "ProductA2" << endl;
}
ProductA2::~ProductA2(){}
ProductB1::ProductB1(){
cout << "ProductB1" << endl;
}
ProductB1::~ProductB1(){}
ProductB2::ProductB2(){
cout << "ProductB2" << endl;
}
ProductB2::~ProductB2(){}“AbstractFactory.h”
#ifndef _ABSTRACTFACTORY_H
#define _ABSTRACTFACTORY_H
class AbstractProductA;
class AbstractProductB;
class AbstractFactory{
public:
~AbstractFactory();
virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
protected:
AbstractFactory();
};
class ConcreteFactory1 :public AbstractFactory{
public:
ConcreteFactory1();
~ConcreteFactory1();
AbstractProductA* CreateProductA();
AbstractProductB* CreateProductB();
};
class ConcreteFactory2 :public AbstractFactory{
public:
ConcreteFactory2();
~ConcreteFactory2();
AbstractProductA* CreateProductA();
AbstractProductB* CreateProductB();
};
#endif“AbstractFactory.cpp”
#include<iostream>
#include"Product.h"
#include"AbstractFactory.h"
using namespace std;
AbstractFactory::AbstractFactory(){}
AbstractFactory::~AbstractFactory(){}
ConcreteFactory1::ConcreteFactory1(){}
ConcreteFactory1::~ConcreteFactory1(){}
AbstractProductA* ConcreteFactory1::CreateProductA(){
return new ProductA1();
}
AbstractProductB* ConcreteFactory1::CreateProductB(){
return new ProductB1();
}
ConcreteFactory2::ConcreteFactory2(){}
ConcreteFactory2::~ConcreteFactory2(){}
AbstractProductA* ConcreteFactory2::CreateProductA(){
return new ProductA2();
}
AbstractProductB* ConcreteFactory2::CreateProductB(){
return new ProductB2();
}“test.cpp”
#include<iostream>
#include"Product.h"
#include"AbstractFactory.h"
using namespace std;
int main(){
AbstractFactory* cfl = new ConcreteFactory1();
cfl->CreateProductA();
cfl->CreateProductB();
AbstractFactory* cfll = new ConcreteFactory2();
cfll->CreateProductA();
cfll->CreateProductB();
system("pause");
return 0;
}
在测试程序中可以看到， 当我们要创建一组对象（ProductA1， ProductA2）的时候我们只用维护一个创建对象（ConcreteFactory1），大大简化了维护的成本和工作。
总结
AbstractFactory 模式是为创建一组（有多类） 相关或依赖的对象提供创建接口， 而 Factory 模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到， AbstractFactory 模式通常都是使用 Factory 模式实现（ConcreteFactory1）。