工厂模式

发表于 更新于

工厂模式

概念

上一篇讲到简单工厂模式，简单工厂模式中，我们建立了一个工厂类，当需要某一类对象的时候，将相应参数传给工厂类，由工厂类来决定生成何种对象。但有一个缺点，如果新增一个产品类，那我们将不得不对工厂类进行修改，增加新的业务逻辑，违反了面向对象编程中的开闭原则。

本文提到的工厂模式是对简单工厂模式的升级和改进。工厂模式是在简单工厂模式的基础上，对“工厂”添加了一个抽象层。将工厂共同的动作抽象出来，作为抽象类，而具体的行为由子类本身去实现，让子类去决定生产什么样的产品。

工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

示例（已测试）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <iostream>

using namespace std;

class Product
{
public:
    Product(){};
    ~Product(){};
    virtual void print(){};
};

class ProductA : public Product
{
public:
    ProductA(){};
    ~ProductA(){};
    void print()
    {
        cout << "this is product A" << endl;
    }
};

class ProductB : public Product
{
public:
    ProductB(){};
    ~ProductB(){};
    void print()
    {
        cout << "this is product B" << endl;
    }
};

class Factory
{
public:
    Factory(){};
    ~Factory(){};
    virtual Product *createProduct() = 0;
};

class ProductAFactory : public Factory
{
public:
    ProductAFactory(){};
    ~ProductAFactory(){};
    Product *createProduct()
    {
        return new ProductA();
    }
};
class ProductBFactory : public Factory
{
public:
    ProductBFactory(){};
    ~ProductBFactory(){};
    Product *createProduct()
    {
        return new ProductB();
    }
};

int main()
{
    Factory *factoryA = new ProductAFactory();
    Product *productA = factoryA->createProduct();
    productA->print();

    Factory *factoryB = new ProductBFactory();
    Product *productB = factoryB->createProduct();
    productB->print();

    if (factoryA != NULL)
    {
        delete factoryA;
        factoryA = NULL;
    }

    if (productA != NULL)
    {
        delete productA;
        productA = NULL;
    }

    if (factoryB != NULL)
    {
        delete factoryB;
        factoryB = NULL;
    }

    if (productB != NULL)
    {
        delete productB;
        productB = NULL;
    }
    return 0;
}

输出：

This is product A
This is product B

总结

  • 在本例中ProductAFactory专门负责ProductA类对象的生成，ProductBFactory专门负责ProductB类对象的生成，如果未来需要新增一个类ProductC，则可以直接继承Factory创建一个ProductCFactory类，负责ProductC类对象的生成，并且测试时也只需单独对一类产品进行测试即可，，符合面向对象设计的原则。

  • 工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

    • 在设计的初期，就考虑到产品在后期会进行扩展的情况下，可以使用工厂方法模式；
    • 产品结构较复杂的情况下，可以使用工厂方法模式；

  • 感想：工厂模式解决了简单工厂模式的弊端，即违反了开闭原则。在简单工厂模式中，如果新增一个产品类，则需要对工厂类方法进行修改，违反了开闭原则，但在工厂模式中，工厂类并不负责实际对象的产生，而是将自身抽象为一个接口，将创建产品对象这一行为推迟到子类中。这样当新增一个产品类时，我们只需要写一个这个类的工厂，继承统一的接口工厂类，然后再实现这个产品类即可，无需对原有的代码进行修改。