简单工厂模式

发表于 更新于

简单工厂模式（Simple Factory Pattern）是设计模式中创建型模式的基础，它不属于GoF（Gang of Four）23种经典设计模式，但因其简洁易用的特性，成为实际开发中最常用的“准设计模式”。核心思想是通过一个工厂类封装对象的创建逻辑，客户端无需直接实例化具体类，只需通过工厂类传入参数即可获取对应实例，降低代码耦合度，提升扩展性。

本文将从简单工厂模式的核心原理出发，分别基于C#、Python、Golang、C++和纯C语言实现该模式，覆盖面向对象（OOP）和过程式编程场景，帮助开发者理解不同语言下的落地方式。

一、简单工厂模式核心结构

简单工厂模式通常包含三个核心角色：

  1. 产品抽象层：定义产品的公共接口/抽象类（OOP语言）或统一的数据结构与函数指针（过程式语言如C）；

  2. 具体产品类：实现/继承抽象层，是实际被创建的对象；

  3. 工厂类：提供静态/普通方法，根据输入参数创建并返回具体产品实例。

二、多语言实现示例

场景说明

以“计算器”为例：定义四则运算（加法、减法）的产品抽象，通过工厂类根据“+”“-”参数创建对应运算实例，最终执行计算逻辑。

1. C# 实现（纯OOP）

C#作为典型的面向对象语言，通过接口定义产品抽象，工厂类封装创建逻辑：

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
using System;

// 1. 产品抽象层：运算接口
public interface IOperation
{
    double Calculate(double num1, double num2);
}

// 2. 具体产品类：加法运算
public class AddOperation : IOperation
{
    public double Calculate(double num1, double num2)
    {
        return num1 + num2;
    }
}

// 2. 具体产品类：减法运算
public class SubtractOperation : IOperation
{
    public double Calculate(double num1, double num2)
    {
        return num1 - num2;
    }
}

// 3. 工厂类：运算工厂
public class OperationFactory
{
    public static IOperation CreateOperation(string oper)
    {
        return oper switch
        {
            "+" => new AddOperation(),
            "-" => new SubtractOperation(),
            _ => throw new ArgumentException("不支持的运算类型")
        };
    }
}

// 客户端调用
class Program
{
    static void Main()
    {
        IOperation addOp = OperationFactory.CreateOperation("+");
        Console.WriteLine("10 + 5 = " + addOp.Calculate(10, 5)); // 输出：15

        IOperation subOp = OperationFactory.CreateOperation("-");
        Console.WriteLine("10 - 5 = " + subOp.Calculate(10, 5)); // 输出：5
    }
}

2. Python 实现（动态OOP）

Python无需显式定义接口，通过抽象基类（ABC）模拟产品抽象，工厂函数实现创建逻辑：

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
from abc import ABC, abstractmethod

# 1. 产品抽象层：运算抽象类
class Operation(ABC):
    @abstractmethod
    def calculate(self, num1, num2):
        pass

# 2. 具体产品类：加法运算
class AddOperation(Operation):
    def calculate(self, num1, num2):
        return num1 + num2

# 2. 具体产品类：减法运算
class SubtractOperation(Operation):
    def calculate(self, num1, num2):
        return num1 - num2

# 3. 工厂函数：运算工厂
def create_operation(oper):
    if oper == "+":
        return AddOperation()
    elif oper == "-":
        return SubtractOperation()
    else:
        raise ValueError("不支持的运算类型")

# 客户端调用
if __name__ == "__main__":
    add_op = create_operation("+")
    print(f"10 + 5 = {add_op.calculate(10, 5)}")  # 输出：15

    sub_op = create_operation("-")
    print(f"10 - 5 = {sub_op.calculate(10, 5)}")  # 输出：5

3. Golang 实现（基于接口的OOP）

Go语言无“类”和“继承”，通过接口实现产品抽象，工厂函数封装创建逻辑（Go推荐使用函数而非结构体作为工厂）：

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
package main

import (
	"errors"
	"fmt"
)

// 1. 产品抽象层：运算接口
type Operation interface {
	Calculate(num1, num2 float64) float64
}

// 2. 具体产品类：加法运算（Go中用结构体模拟类）
type AddOperation struct{}

func (a *AddOperation) Calculate(num1, num2 float64) float64 {
	return num1 + num2
}

// 2. 具体产品类：减法运算
type SubtractOperation struct{}

func (s *SubtractOperation) Calculate(num1, num2 float64) float64 {
	return num1 - num2
}

// 3. 工厂函数：运算工厂
func CreateOperation(oper string) (Operation, error) {
	switch oper {
	case "+":
		return &AddOperation{}, nil
	case "-":
		return &SubtractOperation{}, nil
	default:
		return nil, errors.New("不支持的运算类型")
	}
}

// 客户端调用
func main() {
	addOp, _ := CreateOperation("+")
	fmt.Printf("10 + 5 = %.1f\n", addOp.Calculate(10, 5)) // 输出：15.0

	subOp, _ := CreateOperation("-")
	fmt.Printf("10 - 5 = %.1f\n", subOp.Calculate(10, 5)) // 输出：5.0
}

4. C++ 实现（经典OOP）

C++通过纯虚函数定义产品抽象类，工厂类提供静态方法创建具体产品：

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
#include <iostream>
#include <stdexcept>
using namespace std;

// 1. 产品抽象层：运算抽象类
class Operation {
public:
    virtual double calculate(double num1, double num2) = 0; // 纯虚函数
    virtual ~Operation() = default; // 虚析构函数
};

// 2. 具体产品类：加法运算
class AddOperation : public Operation {
public:
    double calculate(double num1, double num2) override {
        return num1 + num2;
    }
};

// 2. 具体产品类：减法运算
class SubtractOperation : public Operation {
public:
    double calculate(double num1, double num2) override {
        return num1 - num2;
    }
};

// 3. 工厂类：运算工厂
class OperationFactory {
public:
    static Operation* createOperation(string oper) {
        if (oper == "+") {
            return new AddOperation();
        } else if (oper == "-") {
            return new SubtractOperation();
        } else {
            throw invalid_argument("不支持的运算类型");
        }
    }
};

// 客户端调用
int main() {
    Operation* addOp = OperationFactory::createOperation("+");
    cout << "10 + 5 = " << addOp->calculate(10, 5) << endl; // 输出：15
    delete addOp;

    Operation* subOp = OperationFactory::createOperation("-");
    cout << "10 - 5 = " << subOp->calculate(10, 5) << endl; // 输出：5
    delete subOp;

    return 0;
}

5. 纯C语言实现（过程式模拟）

C语言无面向对象特性，通过函数指针+结构体模拟产品抽象，工厂函数返回结构体指针（封装创建逻辑）：

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 1. 产品抽象层：运算结构体（包含函数指针）
typedef struct {
    double (*calculate)(double num1, double num2); // 运算函数指针
} Operation;

// 2. 具体产品实现：加法运算函数
double add_calculate(double num1, double num2) {
    return num1 + num2;
}

// 2. 具体产品实现：减法运算函数
double subtract_calculate(double num1, double num2) {
    return num1 - num2;
}

// 3. 工厂函数：创建运算实例
Operation* create_operation(const char* oper) {
    Operation* op = (Operation*)malloc(sizeof(Operation));
    if (op == NULL) {
        perror("malloc failed");
        exit(EXIT_FAILURE);
    }

    if (strcmp(oper, "+") == 0) {
        op->calculate = add_calculate;
    } else if (strcmp(oper, "-") == 0) {
        op->calculate = subtract_calculate;
    } else {
        free(op);
        fprintf(stderr, "不支持的运算类型\n");
        exit(EXIT_FAILURE);
    }
    return op;
}

// 客户端调用
int main() {
    Operation* add_op = create_operation("+");
    printf("10 + 5 = %.1f\n", add_op->calculate(10, 5)); // 输出：15.0
    free(add_op);

    Operation* sub_op = create_operation("-");
    printf("10 - 5 = %.1f\n", sub_op->calculate(10, 5)); // 输出：5.0
    free(sub_op);

    return 0;
}

三、简单工厂模式的优缺点

优点

  1. 解耦：客户端无需关注产品创建细节，仅需通过工厂调用，符合“开闭原则”（扩展新产品时仅需新增具体产品类+修改工厂逻辑）；

  2. 复用性：创建逻辑集中在工厂，避免重复代码；

  3. 易维护：产品实例的创建逻辑统一管理，修改时仅需调整工厂类。

缺点

  1. 工厂类职责过重：所有产品创建逻辑集中在工厂，新增产品需修改工厂代码，违反“开闭原则”（可通过工厂方法模式优化）；

  2. 产品类型扩展受限：若产品类型过多，工厂类会变得臃肿，可读性和维护性下降；

  3. 难以支持复杂产品创建：无法处理依赖关系复杂的产品实例化。

四、适用场景

  1. 产品类型较少且相对固定，如工具类、简单业务组件；

  2. 客户端无需知道产品创建细节，仅需通过参数获取实例；

  3. 希望统一管理产品创建逻辑，降低客户端与具体产品的耦合。

五、总结

简单工厂模式是创建型模式的入门级实现，不同语言的落地方式虽有差异（OOP语言基于接口/抽象类，过程式语言基于函数指针+结构体），但核心思想一致：封装创建逻辑，简化客户端调用。

在实际开发中，需根据语言特性和业务复杂度选择：OOP语言（C#/Python/Go/C++）可直接通过接口/抽象类实现，过程式语言（C）可通过函数指针模拟；若产品类型频繁扩展，建议升级为工厂方法模式或抽象工厂模式，进一步解耦创建逻辑。

（注：文档部分内容可能由 AI 生成）