抽象工厂模式

2020-12-20

意图:提供一个接口以创建一系列相关或相互依赖的对象，而无需指定它们具体的类。

动机： 在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时由于需求的变化，往往存在更多系列对象的创建工作。

适用性：一个系统要独立于它的产品的创建，组合和表示；一个系统由许多产品系列中的一个配置；要强调一系列相关的产品对象的设计以便进行联合使用；提供一个产品类库，但只想显示它们的接口而不是实现。

结构：

参与者：

AbstractFactory : 声明一个创建抽象产品对象的操作接口

ConcreteFactory: 实现具体创建对象的操作

AbstractProduct : 为一类产品对象声明一个接口

ConcreteProduct : 定义一个将被相应的具体工厂创建的产品对象；实现AbstractProduct的接口

Client : 仅仅使用由AbstractFactory 和AbstractProduct类声明的接口

协作：通常在运行时创建一个ConcreteFactory类的实例。这一具体的工厂创建具有特定实现的产品对象。为创建不同的产品对象，客户应使用不同的具体工厂；AbstractFactory将产品对象的创建延迟到它的ConcreteFactory子类。

效果：

它分离了具体的类，它将客户与类的实现分离
它使得易于交换产品系列
它有利于产品的一致性，当一个系列中的产品对象被设计成一起工作时，一个应用一次只能使用它同一个系列中的对象，这一点很重要。AbstractFactory很容易实现这一点。
难以支持新种类的产品。

实现：

实现时要注意：

将工厂作为单件，即一个应用中每个产品序列只需要一个ConcreteFactory的实例
创建产品
定义可扩展的工厂

代码示例如下：

#include <iostream>
//抽象产品 手机
class AbstractPhone{
public:
  virtual ~AbstractPhone(){}
  virtual void Phone() = 0;
};
//具体产品
class Iphone : public AbstractPhone{
public:
  void Phone(){
    std::cout << " iphone " << std::endl;
  }
};
class XiaomiPhone: public AbstractPhone{
public:
  void Phone(){
    std::cout << " xiao mi " << std::endl;
  }
};
//抽象产品 personal computer
class AbstractPC{
public:
  virtual ~AbstractPC(){}
  virtual void PC() = 0;
};
class MacOs : public AbstractPC{
public:
  void PC(){
    std::cout << " MACOS " << std::endl;
  }
};
class XiaomiPC: public AbstractPC{
public:
  void PC(){
    std::cout << " xiao mi pc" << std::endl;
  }
};
//抽象工厂
class AbstractFactory{
public:
  virtual ~AbstractFactory(){}
  virtual AbstractPhone* createPhone() = 0;
  virtual AbstractPC* createPC() = 0;
};
// apple
class Apple : public  AbstractFactory{
public:
  Apple(){
    _pc = NULL;
    _phone = NULL;
  }
  ~Apple(){}
  AbstractPhone *createPhone(){
    if (_phone == NULL){
      _phone = new Iphone;
    }
    return _phone;
  }
  AbstractPC *createPC(){
    if (_pc == NULL){
      _pc = new MacOs;
    }
    return _pc;
  }
private:
  AbstractPC *_pc;
AbstractPhone *_phone;
};
//小米
class XiaoMi : public  AbstractFactory{
public:
  XiaoMi(){
    _pc = NULL;
    _phone = NULL;
  }
  ~XiaoMi(){}
  AbstractPhone *createPhone(){
    if (_phone == NULL){
      _phone = new XiaomiPhone;
    }
    return _phone;
  }
  AbstractPC *createPC(){
    if (_pc == NULL){
      _pc = new XiaomiPC;
    }
    return _pc;
  }
private:
  AbstractPC *_pc;
  AbstractPhone *_phone;
};
//client
class Client{
public:
  void setFactory(AbstractFactory *factory){
    this->_factory = factory;
  }
  void test(){
    _pc = _factory->createPC();
    _phone = _factory->createPhone();
    _pc->PC();
    _phone->Phone();
  }
private:
  AbstractFactory *_factory;
  AbstractPC *_pc;
  AbstractPhone *_phone;
};
int main(int argc,char **argv)
{
  Client c;
  Apple *apple = new Apple;
  c.setFactory(apple);
  c.test();
  return 0;
}