模板设计模式（Template Method Pattern）

模板设计模式（Template Method Pattern）

模板设计模式是一种行为型设计模式，其核心思想是 定义一个算法的骨架，将某些步骤延迟到子类中实现，从而使得子类可以在不改变算法整体结构的情况下，重新定义某些步骤的具体逻辑。

一、核心思想与要点

核心思想

模板设计模式的核心是 固定算法流程，延迟实现细节。通过在父类中定义算法的主要步骤，子类只需实现具体的细节逻辑即可。

核心要点

  1. 固定流程：父类定义算法的主要步骤（如“烧水 → 冲泡 → 倒入杯子 → 加调料”）。
  2. 可变细节：子类实现具体的步骤（如“如何冲泡茶叶”或“加什么调料”）。
  3. 控制反转：父类控制流程，子类填充细节。

二、Java 实现模板模式的步骤

1. 定义抽象类（模板类）

  • 模板方法：用 final 修饰，定义算法的流程（防止子类覆盖流程）。
  • 抽象方法：用 abstract 修饰，表示必须由子类实现的方法。
  • 具体方法：父类提供默认实现的方法（如公共步骤）。
  • 钩子方法（可选）：提供默认逻辑的方法，子类可选择性覆盖（用于控制流程分支）。
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
public abstract class AbstractClass {
    // 模板方法（final 防止子类覆盖流程）
    public final void templateMethod() {
        step1();
        step2();
        step3();
        if (hookMethod()) { // 钩子方法控制流程分支
            step4();
        }
    }

    // 抽象方法（必须由子类实现）
    protected abstract void step2();

    // 具体方法（默认实现）
    private void step1() {
        System.out.println("执行步骤1");
    }

    // 钩子方法（可选覆盖）
    protected boolean hookMethod() {
        return true; // 默认执行步骤4
    }

    // 另一个具体方法
    private void step3() {
        System.out.println("执行步骤3");
    }

    // 抽象方法
    protected abstract void step4();
}

2. 定义具体子类

子类继承抽象类，并实现其抽象方法。可以覆盖钩子方法以改变流程。

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
public class ConcreteClassA extends AbstractClass {
    @Override
    protected void step2() {
        System.out.println("ConcreteClassA 实现的步骤2");
    }

    @Override
    protected void step4() {
        System.out.println("ConcreteClassA 实现的步骤4");
    }

    // 覆盖钩子方法，禁止执行步骤4
    @Override
    protected boolean hookMethod() {
        return false;
    }
}

public class ConcreteClassB extends AbstractClass {
    @Override
    protected void step2() {
        System.out.println("ConcreteClassB 实现的步骤2");
    }

    @Override
    protected void step4() {
        System.out.println("ConcreteClassB 实现的步骤4");
    }
}

3. 使用模板模式

通过调用模板方法触发算法流程：

1
2
3
4
5
6
7
8
9
public class Client {
    public static void main(String[] args) {
        AbstractClass instanceA = new ConcreteClassA();
        instanceA.templateMethod();

        AbstractClass instanceB = new ConcreteClassB();
        instanceB.templateMethod();
    }
}

输出结果：

1
2
3
4
5
6
7
8
执行步骤1
ConcreteClassA 实现的步骤2
执行步骤3

执行步骤1
ConcreteClassB 实现的步骤2
执行步骤3
ConcreteClassB 实现的步骤4

三、模板模式的优缺点

优点

  1. 复用性高：将通用的算法逻辑封装在父类中，减少代码重复。
  2. 扩展性强：子类可以通过实现抽象方法或覆盖钩子方法来扩展功能。
  3. 控制流程：父类控制整体流程，子类只需关注具体实现。

缺点

  1. 类间耦合性高：父类与子类之间存在较强的依赖关系。
  2. 灵活性受限：算法流程被固定，子类只能在既定框架内扩展。

四、适用场景

  1. 固定流程但部分步骤可变：如制作饮料（固定流程：烧水 → 冲泡 → 倒入杯子 → 加调料）。
  2. 需要控制子类行为：通过钩子方法控制流程分支。
  3. 算法稳定但实现细节多变：如数据处理流程（固定步骤：读取数据 → 处理数据 → 保存数据）。

附录

1. 钩子方法的作用

钩子方法是模板模式中的一个重要特性，用于控制流程分支。其默认实现通常返回一个布尔值，子类可以选择性覆盖以改变流程。

示例：

1
2
3
protected boolean hookMethod() {
    return true; // 默认执行某步骤
}

2. 相关设计模式对比

  • 策略模式：通过组合的方式动态选择算法。
  • 模板模式：通过继承的方式固定算法流程，延迟实现细节。

3. 参考资料