Factory-Method

动机

• 在软件系统中，经常面临着创建对象的工作；由于需求的变化，需要创建的对象的具体类型经常变化。
• 如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合？

模式定义

• 定义一个用于创建对象的接口（纯虚基类），让子类决定实例化哪一个类。 Factory使得一个类的实例化延迟（目的：解耦， 手段：虚函数）到子类。
• 注：自定义1个纯虚工厂基类，其中有个虚方法，它返回我们想要的具体对象，具体实现由具体的工厂子类（工厂子类继承纯虚工厂父类）实现。

#include <iostream>
#include <string>

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

    virtual std::string getName() = 0;
    // ...
};

class ConcreteProductA : public Product
{
public:
    ~ConcreteProductA() {}

    std::string getName()
    {
        return "type A";
    }
    // ...
};

class ConcreteProductB : public Product
{
public:
    ~ConcreteProductB() {}

    std::string getName()
    {
        return "type B";
    }
    // ...
};

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

    virtual Product *createProductA() = 0;
    virtual Product *createProductB() = 0;

    virtual void removeProduct(Product *product) = 0;

    // ...
};

class ConcreteCreator : public Creator
{
public:
    ~ConcreteCreator() {}

    Product *createProductA()
    {
        return new ConcreteProductA();
    }

    Product *createProductB()
    {
        return new ConcreteProductB();
    }

    void removeProduct(Product *product)
    {
        delete product;
    }
    // ...
};

int main()
{
    Creator *creator = new ConcreteCreator();

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

    Product *p2 = creator->createProductB();
    std::cout << "Product: " << p2->getName() << std::endl;
    creator->removeProduct(p2);

    delete creator;
    return 0;
}
/*
Product: type A
Product: type B
*/

何时使用

• 类无法预测它必须创建的对象的类
• 一个类希望它的子类来指定它创建的对象

总结

• Factory模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型，紧耦合关系(new)会导致软件的脆弱。
• Factory Method模式通过面向对象的手法，将所要创建的具体对象工作延迟到子类，从而实现一种扩展（而非更改）的策略，较好地解决了这种紧耦合关系。
• Factory Method模式解决“单个对象”的需求变化。缺点在于要求创建方法/参数相同。