设计模式（二）：抽象工厂模式

定义：

​ ·提供一个创建一系列相关或互相依赖对象的接口，只需要知道对象的系列，无需知道具体的对象。

​ ·在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

主要解决：

​ ·接口选择的问题。

何时使用：

​ ·系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

以代码为例：

​ 类关系图如下

根据类图：

一、创建两个产品族，产品A和产品B，

class ProductA//产品A
{
public:
virtual ~ProductA() {}

virtual const char* getName() = 0;
// ...
};

class ProductB//产品B
{
public:
virtual ~ProductB() {}

virtual const char* getName() = 0;
// ...
};

二、分别创建产品A和产品B的实例类产品等级X和Y

class ConcreteProductAX : public ProductA//产品AX
{
public:
~ConcreteProductAX() {}

const char* getName()
{
return "A-X";
}
// ...
};

class ConcreteProductAY : public ProductA//产品AY
{
public:
~ConcreteProductAY() {}

const char* getName()
{
return "A-Y";
}
// ...
};

class ConcreteProductBX : public ProductB//产品BX
{
public:
~ConcreteProductBX() {}

const char* getName()
{
return "B-X";
}
// ...
};

class ConcreteProductBY : public ProductB//产品BY
{
public:
~ConcreteProductBY() {}

const char* getName()
{
return "B-Y";
}
// ...
};

三、创建抽象工厂类

class AbstractFactory
{
public:
virtual ~AbstractFactory() {}

virtual ProductA *createProductA() = 0;//声明创造产品A的纯虚函数
virtual ProductB *createProductB() = 0;//声明创造产品B的纯虚函数
};

这里抽象工厂类中最重要的是声明的这两个纯虚函数。

四、创建实例抽象工厂类

class ConcreteFactoryX : public AbstractFactory
{
public:
~ConcreteFactoryX() {}

ProductA *createProductA()
{
return new ConcreteProductAX();
}
ProductB *createProductB()
{
return new ConcreteProductBX();
}
// ...
};

class ConcreteFactoryY : public AbstractFactory
{
public:
~ConcreteFactoryY() {}

ProductA *createProductA()
{
return new ConcreteProductAY();
}
ProductB *createProductB()
{
return new ConcreteProductBY();
}
// ...
};

这里声明工厂X和工厂Y来分别实现生产A和B对应的X和Y产品。

五、使用main函数调用

int main()
{
ConcreteFactoryX *factoryX = new ConcreteFactoryX();
ConcreteFactoryY *factoryY = new ConcreteFactoryY();

ProductA *p1 = factoryX->createProductA();
std::cout << "Product: " << p1->getName() << std::endl;

ProductA *p2 = factoryY->createProductA();
std::cout << "Product: " << p2->getName() << std::endl;

delete p1;
delete p2;

delete factoryX;
delete factoryY;

return 0;
}

这样就实现了一个简单的抽象工厂模式

抽象工厂模式的优缺点：

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

**注意事项：**产品族难扩展，产品等级易扩展。