设计模式 - 工厂模式

封面图 • 2025-11-06 • 设计模式

工厂模式（Factory Pattern）是一种**创建型设计模式**，它提供了一种创建对象的方式，而无需指定具体的类。通过工厂模式，对象的创建过程被封装在工厂类中，客户端代码只需要与工厂交互，而不直接与具体类耦合。

---

## 一、工厂模式简介

### 定义：
> 工厂模式定义一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

---

## 二、工厂模式的结构

工厂模式通常包含以下几个角色：

1. **抽象产品（Product）**：定义产品的接口。
2. **具体产品（Concrete Product）**：实现产品接口的具体类。
3. **抽象工厂（Factory）**：声明创建产品的方法。
4. **具体工厂（Concrete Factory）**：实现创建具体产品的操作。

---

## 三、工厂模式的分类

根据实现方式的不同，工厂模式可以分为以下几种：

### 1. 简单工厂模式（Simple Factory）

- 一个工厂类负责创建所有产品。
- 不符合开闭原则（如果新增产品，需要修改工厂类）。

#### 示例（Java）：

```java
// 产品接口
interface Shape {
    void draw();
}

// 具体产品
class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

class Rectangle implements Shape {
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
}

// 简单工厂
class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

// 使用
public class Client {
    public static void main(String[] args) {
        Shape shape1 = ShapeFactory.getShape("CIRCLE");
        shape1.draw();

Shape shape2 = ShapeFactory.getShape("RECTANGLE");
        shape2.draw();
    }
}
```

---

### 2. 工厂方法模式（Factory Method）

- 每个具体工厂对应一种产品。
- 符合开闭原则，新增产品只需扩展工厂类。

#### 示例（Java）：

```java
// 产品接口
interface Product {
    void use();
}

// 具体产品
class ProductA implements Product {
    public void use() {
        System.out.println("Using Product A");
    }
}

class ProductB implements Product {
    public void use() {
        System.out.println("Using Product B");
    }
}

// 抽象工厂
abstract class Creator {
    public abstract Product factoryMethod();
}

// 具体工厂
class CreatorA extends Creator {
    public Product factoryMethod() {
        return new ProductA();
    }
}

class CreatorB extends Creator {
    public Product factoryMethod() {
        return new ProductB();
    }
}

// 使用
public class Client {
    public static void main(String[] args) {
        Creator creatorA = new CreatorA();
        Product productA = creatorA.factoryMethod();
        productA.use();

Creator creatorB = new CreatorB();
        Product productB = creatorB.factoryMethod();
        productB.use();
    }
}
```

---

### 3. 抽象工厂模式（Abstract Factory）

- 提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。
- 适用于需要创建一组相关的对象。

#### 示例（Java）：

```java
// 产品接口
interface Button {
    void render();
}

interface Checkbox {
    void render();
}

// 具体产品
class WindowsButton implements Button {
    public void render() {
        System.out.println("Windows Button");
    }
}

class MacButton implements Button {
    public void render() {
        System.out.println("Mac Button");
    }
}

class WindowsCheckbox implements Checkbox {
    public void render() {
        System.out.println("Windows Checkbox");
    }
}

class MacCheckbox implements Checkbox {
    public void render() {
        System.out.println("Mac Checkbox");
    }
}

// 抽象工厂
interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

// 具体工厂
class WindowsFactory implements GUIFactory {
    public Button createButton() {
        return new WindowsButton();
    }

public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
}

class MacFactory implements GUIFactory {
    public Button createButton() {
        return new MacButton();
    }

public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
}

// 使用
public class Client {
    public static void main(String[] args) {
        GUIFactory factory = new WindowsFactory();
        Button button = factory.createButton();
        Checkbox checkbox = factory.createCheckbox();
        button.render();
        checkbox.render();

factory = new MacFactory();
        button = factory.createButton();
        checkbox = factory.createCheckbox();
        button.render();
        checkbox.render();
    }
}
```

---

## 四、工厂模式的优点

1. **解耦**：客户端不需要知道具体类，只关心接口。
2. **可扩展性强**：新增产品只需添加新的工厂和产品类，不需修改已有代码。
3. **易于维护**：集中管理对象的创建逻辑。

---

## 五、工厂模式的缺点

1. **增加系统复杂度**：引入了多个类，可能让系统更复杂。
2. **不符合开闭原则（简单工厂）**：新增产品时需要修改工厂类。

---

## 六、适用场景

- 当对象的创建逻辑比较复杂，或者需要根据不同条件返回不同对象时。
- 当希望将对象的创建与使用分离，提高系统的灵活性和可维护性时。
- 需要支持多种产品族（如不同操作系统下的UI组件）时。

---

## 七、总结

| 类型         | 是否符合开闭原则 | 是否解耦 | 适用场景                     |
|--------------|------------------|----------|------------------------------|
| 简单工厂     | 否               | 是       | 小规模、固定的产品集合       |
| 工厂方法     | 是               | 是       | 多种产品类型，需要独立创建   |
| 抽象工厂     | 是               | 是       | 一组相关产品，不同平台/环境 |

---

如果你有特定语言（如 Java / Python / C++）的需求，我可以提供更针对性的示例。是否需要？