抽象工厂模式Abstract Factory

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

Java的抽象工厂模型：

abstract class AbstractProductA{
    public abstract void operationA1();
    public abstract void operationA2();
}

class ProductA1 extends AbstractProductA{
    ProductA1(String arg){
        System.out.println("Hello "+arg);
    } // Implement the code here
    public void operationA1() { };
    public void operationA2() { };
}

class ProductA2 extends AbstractProductA{
    ProductA2(String arg){
        System.out.println("Hello "+arg);
    } // Implement the code here
    public void operationA1() { };
    public void operationA2() { };
}

abstract class AbstractProductB{
    //public abstract void operationB1();
    //public abstract void operationB2();
}

class ProductB1 extends AbstractProductB{
    ProductB1(String arg){
        System.out.println("Hello "+arg);
    } // Implement the code here
}

class ProductB2 extends AbstractProductB{
    ProductB2(String arg){
        System.out.println("Hello "+arg);
    } // Implement the code here
}

abstract class AbstractFactory{
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}

class ConcreteFactory1 extends AbstractFactory{
    AbstractProductA createProductA(){
        return new ProductA1("ProductA1");
    }
    AbstractProductB createProductB(){
        return new ProductB1("ProductB1");
    }
}

class ConcreteFactory2 extends AbstractFactory{
    AbstractProductA createProductA(){
        return new ProductA2("ProductA2");
    }
    AbstractProductB createProductB(){
        return new ProductB2("ProductB2");
    }
}

//Factory creator:an indirect way of instantiating factories
class FactoryMaker{
    private static AbstractFactory pf=null;
    static AbstractFactory getFactory(String choice){
        if(choice.equals("a")){
            pf=new ConcreteFactory1();
        }else if(choice.equals("b")){
                pf=new ConcreteFactory2();
            } return pf;
    }
}

// Client
public class Client{
    public static void main(String args[]){
        AbstractFactory pf=FactoryMaker.getFactory("a");
        AbstractProductA product=pf.createProductA();
        //more function calls on product
    }
}

Assignment本次任务要求：

This time we are going to use Abstract Factory to finish this problem.

We have a multi-platform support Graphic programming task that need some widgets of different platform tools.

For example, in Microsoft Windows, we use MFC to produce window widgets.

We are going to design how to use Abstract Factory to finish this job.

Please analyze the main function and then download the executable binary program to meet you result.

解答：
product.hpp:

#ifndef PRODUCT_HPP
#define PRODUCT_HPP

#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

Factory.hpp:

#ifndef FACTORY_HPP
#define FACTORY_HPP
#include "Product.hpp"

class UIFactory {
 public:
  virtual Window* getToolboxWindow() = 0;
  virtual Window* getLayersWindow() = 0;
  virtual Window* getMainWindow() = 0;
  void deleteWindow(Window* w) {
    if (w != NULL) {
      delete w;
    }
  }
};

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

/* Factory for Qt toolkit */
class QtUIFactory : public UIFactory {
 public:
  Window* getToolboxWindow() { return new QtToolboxWindow(); }
  Window* getLayersWindow() { return new QtLayersWindow(); }
  Window* getMainWindow() { return new QtMainWindow(); }
};

/* Factory for MFC toolkit */
class MFCUIFactory : public UIFactory {
 public:
  Window* getToolboxWindow() { return new MFCToolboxWindow(); }
  Window* getLayersWindow() { return new MFCLayersWindow(); }
  Window* getMainWindow() { return new MFCMainWindow(); }
};
#endif

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();
  }

  /* Use the factory to build interface. */
  Window* toolbox = ui->getToolboxWindow();
  Window* layers = ui->getLayersWindow();
  Window* main = ui->getMainWindow();

  /* See what have we recieved. */
  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. AbstractFactory: 定义创建抽象产品的接口方法。
在这里具体为UIFactory，就是一个抽象的父类。

1. ConcreteFactory: 实现方法创建具体的产品。
   在这里具体为MFCUIFactory、GtkUIFactory、QtUIFactory三个具体的工厂。

2. AbstractProduct: 声明不同类型的产品的接口。
   在这里是一种具体类型的产品：Window，也可以加上其他的产品，即这个工厂生产的产品。

3. Product: 定义ConcreteFactory对应的具体产品，实现AbstractProduct接口。在这里对应的是Window的Toolbox、Layers、Main三种。
   Toolbox、Layers、Main三种还可以有自己具体的操作operation1、operation2等。

4. Client: 使用AbstractFactory和AbstractProduct类。

一点提示：delete指针之前一定要判断它是否有赋值过，或者是否是
NULL！！！