设计模式之工厂方法模式

---

1、 概述

工厂方法（Factory Method）模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式，它属于类创建型模式。 在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而子类负责生成具体产品对象，这样做的目的是将产品类的实例化延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

2、 图解

现在有A、B、C三种产品，相对应的有三个工厂：工厂A负责生产A产品，工厂B负责生产B产品，工厂C负责生产C产品。这时候客户不需要告诉工厂生产哪种产品了，只需要告诉对应的工厂生产就可以了。

工厂方法模式包含如下角色：

• Factory 抽象工厂角色：

  是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

• ConcreteFactory 具体工厂角色（图中的FactoryA、FactoryB、FactoryC）

  实现抽象工厂接口的具体工厂类，被应用程序调用以创建产品对象。

• Product 抽象产品角色：

  抽象产品角色是所创建所有对象的父类，负责描述所有实例的公共接口。

• ConcreteProduct 具体产品角色（图中的ProductA、ProductB、ProductC）：

  实现了抽象产品角色所定义的接口 ，由专门的具体工厂角色创建。

  ​

3、 优缺点

优点：

• 子类提供挂钩。基类为工厂方法提供缺省实现，子类可以重写新的实现，也可以继承父类的实现。– 加一层间接性，增加了灵活性

• 屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。

• 典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。

• 多态性：客户代码可以做到与特定应用无关，适用于任何实体类。

缺点：

• 添加新产品时，需要编写新的具体产品类 ，而且还要提供与之对应的具体工厂类，系统中类的将成对增加，在一定程度上增加了系统的复杂度。
• 由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。

4、 应用场景

如果一个对象拥有很多子类，那么创建该对象的子类使用工厂模式是最合适的，不但可以面向接口的编程，为维护以及开发带来方便。

如果创建某个对象时需要进行许多额外的操作，如查询数据库然后将查询到的值赋予要创建的对象(单例初始化时使用比较多),或是需要许多额外的赋值等等。如果查看JDK源码中，会发现许多成员变量在对象构造时，通过工厂方法进行创建的。因为这些成员变量本身的创建也很复杂。不可能创建对象时，在该对象的构造方法里创建成员变量然后再赋值给该成员变量。而且使用工厂模式也提高了代码的重用性。

5、 实例

5.1 product.h

#ifndef PRODUCT_H
#define PRODUCT_H

#include <iostream>

// 产品基类
class Product
{
public:
    Product() {}
    virtual ~Product(){}

    virtual void detail() const
    {
        std::cout << "This is the base class of product." << std::endl;
    }
};

// 产品A
class ProductA : public Product
{
public:
    ProductA() {}
    ~ProductA() {}

    virtual void detail() const
    {
        std::cout << "This is ProductA." << std::endl;
    }
};

// 产品B
class ProductB : public Product
{
public:
    ProductB() {}
    ~ProductB() {}

    virtual void detail() const
    {
        std::cout << "This is ProductB." << std::endl;
    }
};

// 产品C
class ProductC : public Product
{
public:
   ProductC() {}
   ~ProductC() {}

    virtual void detail() const
    {
        std::cout << "This is ProductC." << std::endl;
    }
};

#endif // PRODUCT_H

5.2 factory.h

#ifndef FACTORY_H
#define FACTORY_H

#include "product.h"

// 工厂基类
class Factory
{
public:
    Factory(){}
    virtual ~Factory(){}

    static Product* produce()
    {
        return NULL;
    }
};

// 工厂A
class FactoryA : public Factory
{
public:
    FactoryA();
    virtual ~FactoryA();

    static Product* produce()
    {
        return new ProductA();
    }
};

// 工厂B
class FactoryB : public Factory
{
public:
    FactoryB();
    virtual ~FactoryB();

    static Product* produce()
    {
        return new ProductB();
    }
};

// 工厂C
class FactoryC : public Factory
{
public:
    FactoryC();
    virtual ~FactoryC();

    static Product* produce()
    {
        return new ProductC();
    }
};

#endif // FACTORY_H

5.3 main.cpp

#include <iostream>

#include "factory.h"

using namespace std;

int main()
{
    Product* productA = NULL;
    productA = FactoryA::produce();
    productA->detail();
    cout << "==============" << endl;

    Product* productB = NULL;
    productB = FactoryB::produce();
    productB->detail();
    cout << "==============" << endl;

    Product* productC = NULL;
    productC = FactoryC::produce();
    productC->detail();
    cout << "==============" << endl;

    delete productA;
    delete productB;
    delete productC;

    return 0;
}

运行结果