AbstractFactory模式就是用来解决这类问题的:要创建一组相关或者相互依赖的对象。
AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的(ConcreteFactory)中,维护这样一个创建类总比维护n多相关对象的创建过程要简单的多。
AbstractFactory模式典型的结构图为:
代码如下:
- //AbstractProduct.h
- #ifndef _ABSTRACTPRODUCT_H_
- #define _ABSTRACTPRODUCT_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
- //AbstractractProduct.cpp
- #include "AbstractProduct.h"
- #include <iostream.h>
- AbstractProductA::AbstractProductA()
- {
- }
- AbstractProductA::~AbstractProductA()
- {
- }
- AbstractProductB::AbstractProductB()
- {
- }
- AbstractProductB::~AbstractProductB()
- {
- }
- ProductA1::~ProductA1()
- {
- }
- ProductA1::ProductA1()
- {
- cout<<"Constructing ProductA1..."<<endl;
- }
- ProductA2::~ProductA2()
- {
- }
- ProductA2::ProductA2()
- {
- cout<<"Constructing ProductA2..."<<endl;
- }
- ProductB1::~ProductB1()
- {
- }
- ProductB1::ProductB1()
- {
- cout<<"Constructing ProductB1"<<endl;
- }
- ProductB2::~ProductB2()
- {
- }
- ProductB2::ProductB2()
- {
- cout<<"Constructing ProductB2..."<<endl;
- }
- //AbstractFactory.h
- #ifndef _ABSTRACTFACTORY_H_
- #define _ABSTRACTFACTORY_H_
- class AbstractProductA;
- class AbstractProductB;
- class AbstractFactory
- {
- public:
- virtual ~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 "AbstractFactory.h"
- #include "AbstractProduct.h"
- AbstractFactory::AbstractFactory()
- {
- }
- AbstractFactory::~AbstractFactory()
- {
- }
- ConcreteFactory1::ConcreteFactory1()
- {
- }
- ConcreteFactory1::~ConcreteFactory1()
- {
- }
- ConcreteFactory2::ConcreteFactory2()
- {
- }
- ConcreteFactory2::~ConcreteFactory2()
- {
- }
- AbstractProductA* ConcreteFactory1::createProductA()
- {
- return new ProductA1();
- }
- AbstractProductB* ConcreteFactory1::createProductB()
- {
- return new ProductB1();
- }
- AbstractProductA* ConcreteFactory2::createProductA()
- {
- return new ProductA2();
- }
- AbstractProductB* ConcreteFactory2::createProductB()
- {
- return new ProductB2();
- }
AbstractFactory模式和Factory模式的区别是初学(使用)设计模式时候的一个容易引起困惑的地方。实际上,AbstractFactory模式是为创建一组(有多类)相关或依赖的对象提供创建接口,而Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到,AbstractFactory模式通常都是使用Factory模式实现(ConcreteFactory1)。