设计模式的实现(C++)------抽象工厂模式（AbstractFactory）

创建型模式（1）---抽象工厂模式

 

①定义：

      如果客户端需要创建一个产品结构，而这写产品结构又属于不同的产品类别，则可以考虑使用抽象工厂模式，抽象工厂模式中的抽象工厂类负责创建对象的接口。这一系列的产品结构的实现则交给实现抽象工厂类的具体工厂类来完成。

 

②原理：

      抽象工厂模式主要由四部分组成：抽象工厂类、实现抽象工厂的具体工厂类、抽象类以及实现抽象类的具体对象类。

 

③优点：

      客户端不负责对象的创建，而交由实现抽象工厂类的具体工厂类去完成，客户端只负责对象的调用，明确了各个类的职责。

      当一系列相互关联的类被设计到一个工厂类的时候，客户端的调用就变得非常简单；如果需要更换一个产品系列的话，只需要更换一个工厂类就可以了。

 

④缺点：

      如果有新的产品加进来的话，就需要修改抽象工厂类，并同时修改实现这个抽象工厂类的具体工厂类，需要额外编写代码，增加了工作量，也违背了开放封闭原则。

 

⑤代码：

AbstractFactory.h:

#ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H

//产品A抽象类
class ProductA
{
public:
 virtual ~ProductA(){};
 //类A的动作
 virtual void doProA() = 0;
};

//产品B抽象类
class ProductB
{
public:
 virtual ~ProductB(){};
 //类B的动作
 virtual void doProB() = 0;
};

//抽象工厂类
class AbstractFactory{
public:
 virtual ~AbstractFactory(){};
 //创建产品A
 virtual ProductA* createProductA() = 0;
 //创建产品B
 virtual ProductB* createProductB() = 0;
};

//创建产品系列工厂1
class ProductFactory1 : public AbstractFactory
{
public:
 ProductFactory1();
 virtual ~ProductFactory1();
 ProductA* createProductA();
 ProductB* createProductB();
};

//具体产品类A1
class ProductA1 : public ProductA
{
public:
 ProductA1();
 virtual ~ProductA1();
 void doProA();
};

//具体产品类B1
class ProductB1 : public ProductB
{
public:
 ProductB1();
 virtual ~ProductB1();
 void doProB();
};

#endif

 

AbstractFactory.cpp

 

#include "AbstractFactory.h"
#include
using namespace std;

ProductFactory1::~ProductFactory1()
{
 cout<<"Delete ProductFactory1"<}

ProductFactory1::ProductFactory1()
{
 cout<<"Create ProductFactory1"<}

ProductA* ProductFactory1::createProductA()
{
 return new ProductA1();
}

ProductB* ProductFactory1::createProductB()
{
 return new ProductB1();
}

ProductA1::ProductA1()
{
 cout<<"Create ProductA1"<}

ProductA1::~ProductA1()
{
 cout<<"Delete ProductA1"<}

void ProductA1::doProA()
{
 cout<<"action of the ProductA1"<}

ProductB1::ProductB1()
{
 cout<<"Create ProductB1"<}

ProductB1::~ProductB1()
{
 cout<<"Delete ProductB1"<}

void ProductB1::doProB()
{
 cout<<"action of the ProductB1"<}

 

测试代码：

int main(){
 cout<<"Abstract Factory start"<

 //创建工厂接口
 AbstractFactory* factory = new ProductFactory1();

 //创建产品A1
 ProductA* pA1  = factory->createProductA();
 pA1->doProA();

 //创建产品B1
 ProductB* pB1  = factory->createProductB();
 pB1->doProB();

 //删除对象
 delete factory;
 delete pA1;
 delete pB1;
 return 0;
}