什么是简单工厂模式？

简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，它通过一个工厂类统一负责创建其他类的实例，客户端无需直接实例化具体对象，只需向工厂传递参数，由工厂决定创建哪种类型的对象。

其核心作用是将对象的创建逻辑与使用逻辑分离，降低客户端与具体类的耦合，便于后续扩展（如新增产品类型时，只需修改工厂类，无需修改客户端）。

简单工厂模式的核心角色

1. 抽象产品（Product）：定义所有具体产品的公共接口（或父类）。
2. 具体产品（ConcreteProduct）：实现抽象产品接口的具体类，是工厂创建的目标。
3. 工厂（Factory）：包含创建具体产品的逻辑，根据输入参数返回对应的产品实例。

JavaScript 实现简单工厂模式示例：计算器工厂

以下以 “计算器” 为例，实现简单工厂模式。工厂根据输入的运算符（+、-、*、/），创建对应的运算器实例并执行计算。

代码实现 - Javascript

// -------------- 1. 抽象产品：运算器基类（定义公共接口）--------------
class Operation {
  constructor() {
    this.numberA = 0; // 操作数A
    this.numberB = 0; // 操作数B
  }

  // 抽象计算方法（由子类实现）
  calculate() {
    throw new Error("子类必须实现 calculate 方法");
  }
}

// -------------- 2. 具体产品：各种运算器 --------------
// 加法运算器
class AddOperation extends Operation {
  calculate() {
    return this.numberA + this.numberB;
  }
}

// 减法运算器
class SubtractOperation extends Operation {
  calculate() {
    return this.numberA - this.numberB;
  }
}

// 乘法运算器
class MultiplyOperation extends Operation {
  calculate() {
    return this.numberA * this.numberB;
  }
}

// 除法运算器
class DivideOperation extends Operation {
  calculate() {
    if (this.numberB === 0) {
      throw new Error("除数不能为0");
    }
    return this.numberA / this.numberB;
  }
}

// -------------- 3. 工厂类：创建运算器实例 --------------
class OperationFactory {
  // 根据运算符创建对应的运算器
  static createOperation(operator) {
    let operation;
    switch (operator) {
      case "+":
        operation = new AddOperation();
        break;
      case "-":
        operation = new SubtractOperation();
        break;
      case "*":
        operation = new MultiplyOperation();
        break;
      case "/":
        operation = new DivideOperation();
        break;
      default:
        throw new Error("不支持的运算符");
    }
    return operation;
  }
}

// -------------- 使用示例 --------------
// 客户端无需直接实例化 AddOperation 等类，只需通过工厂创建
const addOp = OperationFactory.createOperation("+");
addOp.numberA = 10;
addOp.numberB = 5;
console.log("10 + 5 =", addOp.calculate()); // 输出：15

const multiplyOp = OperationFactory.createOperation("*");
multiplyOp.numberA = 8;
multiplyOp.numberB = 4;
console.log("8 * 4 =", multiplyOp.calculate()); // 输出：32

const divideOp = OperationFactory.createOperation("/");
divideOp.numberA = 20;
divideOp.numberB = 5;
console.log("20 / 5 =", divideOp.calculate()); // 输出：4

代码说明

1. 抽象产品（Operation）：定义了运算器的公共属性（numberA、numberB）和抽象方法 calculate，所有具体运算器都继承此类。
2. 具体产品（AddOperation 等）：分别实现了加法、减法等具体运算逻辑，专注于自身的计算功能。
3. 工厂（OperationFactory）：通过静态方法 createOperation 根据运算符参数，创建并返回对应的运算器实例。客户端只需调用工厂方法，无需关心具体类的实例化细节。

简单工厂模式的优势

• 解耦：客户端无需知道具体产品的类名，只需通过工厂参数获取对象，降低耦合。
• 易扩展：若新增运算类型（如取模 %），只需新增一个 ModOperation 类，并在工厂中添加对应的 case 分支，客户端代码无需修改。
• 统一管理：对象创建逻辑集中在工厂类中，便于维护（如修改创建规则时只需改工厂）。

适用场景

• 产品类型较少且固定，适合简单场景（若产品类型极多，工厂类可能过于庞大，需考虑工厂方法模式）。
• 客户端不需要知道对象的创建细节，只需 “按需获取” 对象。

简单工厂模式是工厂模式中最基础的实现，核心思想是 “集中创建，简化使用”。