简单工厂模式介绍

文章目录

- [1. 引言：从一个常见问题说起](#1. 引言：从一个常见问题说起)
- [2. 什么是简单工厂模式](#2. 什么是简单工厂模式)
- - 核心思想
- [3. 简单工厂模式的角色组成](#3. 简单工厂模式的角色组成)
- [4. 示例：不用工厂的写法（问题代码）](#4. 示例：不用工厂的写法（问题代码）)
- [5. 引入简单工厂模式](#5. 引入简单工厂模式)
- - [5.1 抽象产品](#5.1 抽象产品)
  - [5.2 具体产品实现](#5.2 具体产品实现)
  - [5.3 具体工厂（核心）](#5.3 具体工厂（核心）)
  - [5.4 客户端使用](#5.4 客户端使用)
- [6. 简单工厂模式的优点](#6. 简单工厂模式的优点)
- [7. 简单工厂模式的缺点](#7. 简单工厂模式的缺点)
- [8. 适用场景](#8. 适用场景)
- - 适合使用：
  - 不适合使用：
- 参考

1. 引言：从一个常见问题说起

在面向对象编程中，我们经常会遇到这样的代码：

java 复制代码

if ("circle".equals(type)) {
    shape = new Circle();
} else if ("rectangle".equals(type)) {
    shape = new Rectangle();
} else if ("triangle".equals(type)) {
    shape = new Triangle();
}

这类代码有几个明显问题：

创建逻辑分散在业务代码中
新增产品时需要修改大量 if-else
违反了开闭原则（对扩展开放，对修改关闭）
对具体类产生了强耦合

问题的根源在于：

对象的创建与使用耦合在了一起。

而简单工厂模式，正是用来解决这一问题的经典方案。

2. 什么是简单工厂模式

简单工厂模式（Simple Factory Pattern）严格来说并不是 GoF 23 种设计模式之一，而是一种常用的创建型设计思想。

核心思想

由一个专门的工厂类，负责根据条件创建不同的产品对象，客户端只关心使用，不关心创建。

3. 简单工厂模式的角色组成

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

抽象产品（Product）
- 定义产品的公共接口
具体产品（ConcreteProduct）
- 实现抽象产品接口
具体工厂（Factory）
- 负责创建具体产品实例

结构示意：

plain 复制代码

Client → Factory → ConcreteProduct
            ↑
         Product

4. 示例：不用工厂的写法（问题代码）

以"计算器"为例，假设我们要实现加减乘除：

java 复制代码

public class Calculator {

    public static double calculate(String op, double a, double b) {
        if ("+".equals(op)) {
            return a + b;
        } else if ("-".equals(op)) {
            return a - b;
        } else if ("*".equals(op)) {
            return a * b;
        } else if ("/".equals(op)) {
            return a / b;
        }
        throw new IllegalArgumentException("不支持的操作");
    }
}

问题总结：

所有逻辑集中在一个方法中
新增运算符必须修改原代码
可维护性差

5. 引入简单工厂模式

5.1 抽象产品

java 复制代码

public interface Operation {
    double apply(double a, double b);
}

5.2 具体产品实现

java 复制代码

public class AddOperation implements Operation {
    public double apply(double a, double b) {
        return a + b;
    }
}

java 复制代码

public class SubOperation implements Operation {
    public double apply(double a, double b) {
        return a - b;
    }
}

java 复制代码

public class MulOperation implements Operation {
    public double apply(double a, double b) {
        return a * b;
    }
}

java 复制代码

public class DivOperation implements Operation {
    public double apply(double a, double b) {
        return a / b;
    }
}

5.3 具体工厂（核心）

java 复制代码

public class OperationFactory {

    public static Operation createOperation(String op) {
        switch (op) {
            case "+":
                return new AddOperation();
            case "-":
                return new SubOperation();
            case "*":
                return new MulOperation();
            case "/":
                return new DivOperation();
            default:
                throw new IllegalArgumentException("不支持的操作类型");
        }
    }
}

5.4 客户端使用

java 复制代码

public class Client {
    public static void main(String[] args) {
        Operation operation = OperationFactory.createOperation("+");
        double result = operation.apply(3, 5);
        System.out.println(result);
    }
}

此时客户端的变化：

不再依赖具体实现类
只依赖抽象接口 Operation
创建逻辑集中管理

6. 简单工厂模式的优点

解耦对象创建与使用
客户端代码更加简洁
创建逻辑集中，易于维护
符合单一职责原则

7. 简单工厂模式的缺点

不符合开闭原则
- 每增加一个产品，就要修改工厂类
工厂类职责过重，容易膨胀
扩展性有限

正因如此，才有了工厂方法模式 和抽象工厂模式。

8. 适用场景

适合使用：

产品种类较少
创建逻辑相对简单
系统对扩展要求不高
教学、Demo、小型系统

不适合使用：

产品类型频繁变化
大型复杂系统
需要严格遵循开闭原则的架构

参考

工厂模式 | 菜鸟教程

简单工厂模式