抽象工厂模式(Abstract Factory Pattern)

1.定义:

抽象工厂模式:提供一个创建一系列相关的或相互依赖对象的接口,而无须指定他们具体的类.抽象工厂模式又称为Kit模式,它是一种对象创建型模式.

2.说明

在抽象工厂模式中,每一个具体工厂都提供了多个工厂方法用于产生多种不同类型的产品,这些产品构成了一个产品族.

3.结构

(1)AbstractFactory(抽象工厂):它声明了一组用于创建一族产品的方法,每一个方法对应一种产品
(2)ConcreteFactory(具体工厂):它实现了在抽象工厂中声明的创建产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品都位于某个产品等级结构中.
(3)AbstractProduct(抽象产品):它为每种产品声明接口,在抽象产品中声明了产品所具有的业务方法.
(4)ConcreteProduct(具体产品):它定义具体工厂生产的具体产品对象,实现在抽象产品接口中声明的业务方法:

注:在抽象工厂中声明了多个工厂方法,用于创建不同类型的产品,抽象工厂可以是接口也可以是抽象类或者是具体类.

4.粒子

(1)Product.hpp

#ifndef PRODUCT
#define PRODUCT
#include <iostream>
#include <string>

class Window {
protected:
    int width;
    int height;
    std::string toolkit;
    std::string type;

  Window(std::string usedToolkit, std::string windowType)
      : toolkit(usedToolkit), type(windowType) {}

 public:
    virtual ~Window() {}
    std::string getToolkit() {
    return toolkit; 
 }
    std::string getType() { 
        return type;   
    }
};

class GtkToolboxWindow : public Window {
 public:
    GtkToolboxWindow() : Window("Gtk", "ToolboxWindow") {}
};

class GtkLayersWindow : public Window {
 public:
    GtkLayersWindow() : Window("Gtk", "LayersWindow") {}
};

class GtkMainWindow : public Window {
 public:
    GtkMainWindow() : Window("Gtk", "MainWindow") {}
};

class QtToolboxWindow : public Window {
 public:
    QtToolboxWindow() : Window("Qt", "ToolboxWindow") {}
};

class QtLayersWindow : public Window {
 public:
    QtLayersWindow() : Window("Qt", "LayersWindow") {}
};

class QtMainWindow : public Window {
 public:
    QtMainWindow() : Window("Qt", "MainWindow") {}
};

class MFCToolboxWindow : public Window {
 public:
    MFCToolboxWindow() : Window("MFC", "ToolboxWindow") {}
};

class MFCLayersWindow : public Window {
 public:
    MFCLayersWindow() : Window("MFC", "LayersWindow") {}
};

class MFCMainWindow : public Window {
 public:
    MFCMainWindow() : Window("MFC", "MainWindow") {}
};

#endif

(2)Factory.hpp

#ifndef FACTORY
#define FACTORY
#include "Product.hpp"
//抽象类.声明了方法,具体在子类中实现
class UIFactory {
 public:
  virtual Window* getToolboxWindow() = 0;  //  pure virtual abstract function 纯虚函数
  virtual Window* getLayersWindow() = 0;
  virtual Window* getMainWindow() = 0;
  void deleteWindow(Window* w) {
    if (!w) {
      delete w;
    }
  }
};

class GtkUIFactory : public UIFactory {
 public:
    Window* getToolboxWindow() { 
        return new GtkToolboxWindow();
   }
    Window* getLayersWindow() { 
        return new GtkLayersWindow(); 
    }
    Window* getMainWindow() { 
        return new GtkMainWindow(); 
    }
};

class QtUIFactory : public UIFactory {
 public:
    Window* getToolboxWindow() { 
        return new QtToolboxWindow(); 
    }
    Window* getLayersWindow() { 
        return new QtLayersWindow();
        //  父类的指针可以指向子类,但是子类的指针不可以指向父类
    }
    Window* getMainWindow() { 
        return new QtMainWindow(); 
    }
};

class MFCUIFactory : public UIFactory {
 public:
    Window* getToolboxWindow() { 
        return new MFCToolboxWindow();
    }
    Window* getLayersWindow() { 
        return new MFCLayersWindow(); 
    }
    Window* getMainWindow() { 
        return new MFCMainWindow(); 
    }
};

#endif

(3)Client.cpp

#include <iostream>
#include <string>

#include "Factory.hpp"
#include "Product.hpp"

int main() {
  UIFactory* ui = 0;

  int choose;

  std::cin >> choose;

  switch (choose) {
    case 0:
      ui = new MFCUIFactory();
      break;
    case 1:
      ui = new GtkUIFactory();
      break;
    case 2:
    default:
      ui = new QtUIFactory();
  }

  Window* toolbox = ui->getToolboxWindow();
  Window* layers = ui->getLayersWindow();
  Window* main = ui->getMainWindow();

  std::cout << toolbox->getToolkit() << ":" << toolbox->getType() << std::endl;
  std::cout << layers->getToolkit() << ":" << layers->getType() << std::endl;
  std::cout << main->getToolkit() << ":" << main->getType() << std::endl;

  ui->deleteWindow(toolbox);
  ui->deleteWindow(layers);
  ui->deleteWindow(main);

  delete ui;
}

运行结果是:

1
Gtk:ToolboxWindow
Gtk:LayersWindow
Gtk:MainWindow

5.使用场景

(1)一个系统不应当依赖于产品类实例如何被创,组合和表达的细节,这对于所有类型的工厂模式都很重要,用户无须关心对象的创建过程,将对象的创建和使用解耦.
(2)系统中多于一个的产品族,而每次只使用其中某一产品族.可以通过配置文件等方式来使得用户可以动态改变产品族,也可以很方便地增加新的产品族.
(3)属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来.同一个产品族中的产品可以是没有任何关系的对象,但是他们都具有一些共同的约束.
(4)产品等级结构稳定,设计完成之后,不会向系统中增加新的产品等级结构或者删除已有的产品等级结构.