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

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

定义：

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

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

主要解决：

​ ·接口选择的问题。

何时使用：

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

以代码为例：

​ 类关系图如下

根据类图：

一、创建两个产品族，产品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 里加代码，又要在具体的里面加代码。

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