设计模式 - 抽象工厂模式

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

抽象工厂模式（Abstract Factory Pattern）是一种**创建型设计模式**，它提供一个接口，用于创建**相关或依赖对象的家族**，而无需指定它们的具体类。

---

## 一、定义

> **抽象工厂模式**：提供一个接口，用于创建一系列相关或相互依赖的对象，而不需要指定它们具体的类。

---

## 二、核心思想

- **抽象工厂**：定义创建一系列产品的方法。
- **具体工厂**：实现抽象工厂接口，负责创建一组具体的产品。
- **产品族**：同一抽象工厂可以创建的一组相关产品（例如：Windows 和 Mac 的 UI 控件）。
- **产品等级结构**：不同抽象工厂创建的不同产品（例如：Windows 操作系统的按钮和文本框）。

---

## 三、适用场景

1. 系统需要独立于其产品的创建、组合和表示。
2. 需要创建多个相关对象的家族。
3. 需要保证系统中的一致性（如：UI 控件风格统一）。

---

## 四、UML 类图结构

```
+-------------------+
|   AbstractFactory |
+-------------------+
| + createProductA()|
| + createProductB()|
+-------------------+
          ^
          |
+-------------------+
|   ConcreteFactory |
+-------------------+
| + createProductA()|
| + createProductB()|
+-------------------+
          ^
          |
+-------------------+     +-------------------+
|   ProductA        |     |   ProductB        |
+-------------------+     +-------------------+
| + operationA()    |     | + operationB()    |
+-------------------+     +-------------------+
```

---

## 五、Java 示例代码

### 1. 定义产品接口

```java
// 产品 A
interface ProductA {
    void operationA();
}

// 产品 B
interface ProductB {
    void operationB();
}
```

### 2. 定义抽象工厂

```java
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}
```

### 3. 实现具体工厂

```java
// 具体工厂 1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

@Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂 2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

@Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}
```

### 4. 实现具体产品

```java
// 产品 A1
class ProductA1 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("ProductA1 operation");
    }
}

// 产品 A2
class ProductA2 implements ProductA {
    @Override
    public void operationA() {
        System.out.println("ProductA2 operation");
    }
}

// 产品 B1
class ProductB1 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("ProductB1 operation");
    }
}

// 产品 B2
class ProductB2 implements ProductB {
    @Override
    public void operationB() {
        System.out.println("ProductB2 operation");
    }
}
```

### 5. 使用示例

```java
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();

ProductA a = factory.createProductA();
        ProductB b = factory.createProductB();

a.operationA(); // 输出: ProductA1 operation
        b.operationB(); // 输出: ProductB1 operation
    }
}
```

---

## 六、优点

- 将客户端与具体类解耦，提高灵活性。
- 确保产品族的一致性。
- 符合“开闭原则”，增加新功能时只需扩展工厂，不需修改已有代码。

---

## 七、缺点

- 增加了系统的复杂度。
- 如果产品族太多，会导致类数量爆炸。
- 对于简单对象，使用工厂模式可能更合适。

---

## 八、实际应用举例

- **GUI 框架**：比如 Java Swing 或 Qt，根据操作系统创建不同的控件。
- **数据库连接**：根据不同数据库类型（MySQL、PostgreSQL）创建不同的连接器。
- **日志系统**：支持多种日志输出方式（文件、控制台、网络）。

---

如果你有特定的应用场景或者想了解与其他设计模式（如工厂方法、单例等）的区别，也可以告诉我，我可以进一步帮你分析。