设计模式：模板方法模式

“模板方法模式是一种行为型设计模式，它定义了一个算法的骨架，并允许子类在不改变算法结构的情况下重新定义算法的某些步骤。通过这种模式，父类控制了算法的整体流程，子类可以实现具体的步骤。

模板方法模式的优点包括：

  • 代码复用：算法的通用部分在父类中实现，避免了重复代码，提高了代码的复用性。
  • 灵活性：子类可以根据需要重写父类中的某些步骤，而不影响算法的整体结构。
  • 易于维护：算法的框架在父类中实现，修改父类代码即可影响所有子类。
  • 遵循开闭原则：对修改关闭，对扩展开放，子类可以扩展算法的步骤。

模板方法模式的缺点包括：

  • 子类数量增加：每个不同的实现都需要创建一个子类，可能导致子类数量的增加。
  • 灵活性降低：算法的框架在父类中定义，子类不能改变算法的整体结构。

一个典型的例子是游戏开发中，游戏的初始化、开始和结束是固定的流程，但每种游戏（如足球、篮球）有不同的实现。我们可以使用模板方法模式来定义游戏的框架，并让不同的游戏子类实现具体的步骤。”

1. 什么是模板方法模式？

模板方法模式（Template Method Pattern）是一种行为型设计模式，它定义了一个算法的骨架（即模板），并允许子类在不改变算法结构的情况下重新定义算法的某些步骤。通过这种模式，子类可以实现算法中的某些步骤，而整个算法的框架由父类控制。

模板方法模式的核心思想是：父类提供了算法的结构和步骤顺序，但具体的某些步骤留给子类去实现。这种模式可以避免重复代码，提高代码的复用性，同时确保算法的整体流程一致。

2. 模板方法模式的结构

模板方法模式通常包含以下几个角色：

  • 抽象类（AbstractClass）：定义算法的骨架，并在模板方法中调用基本操作。模板方法是定义在抽象类中的，通常是final方法，防止子类改变算法的结构。
  • 具体子类（ConcreteClass）：实现抽象类中定义的基本操作，完成算法中的具体步骤。

image-20240904173634591

注意这里的step1,step2都是抽象方法

3. 模板方法模式的实现

以下是一个使用 Java 实现模板方法模式的简单示例，假设我们有一个游戏框架，不同类型的游戏（如足球、篮球）有不同的实现，但游戏的流程（如初始化、开始、结束）是固定的。

1. 定义抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 抽象类，定义了游戏的算法骨架
public abstract class Game {
    // 模板方法，定义了游戏的基本流程
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }

    // 基本操作，由子类实现
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();
}

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
30
31
32
33
34
35
// 具体子类，实现足球游戏
public class Football extends Game {
    @Override
    void initialize() {
        System.out.println("Football Game Initialized! Start playing.");
    }

    @Override
    void startPlay() {
        System.out.println("Football Game Started. Enjoy the game!");
    }

    @Override
    void endPlay() {
        System.out.println("Football Game Finished!");
    }
}

// 具体子类，实现篮球游戏
public class Basketball extends Game {
    @Override
    void initialize() {
        System.out.println("Basketball Game Initialized! Start playing.");
    }

    @Override
    void startPlay() {
        System.out.println("Basketball Game Started. Enjoy the game!");
    }

    @Override
    void endPlay() {
        System.out.println("Basketball Game Finished!");
    }
}

3. 使用模板方法模式

1
2
3
4
5
6
7
8
9
public class Client {
    public static void main(String[] args) {
        Game football = new Football();
        football.play();  // 输出足球游戏的流程

        Game basketball = new Basketball();
        basketball.play();  // 输出篮球游戏的流程
    }
}

4. 运行结果

1
2
3
4
5
6
7
Football Game Initialized! Start playing.
Football Game Started. Enjoy the game!
Football Game Finished!

Basketball Game Initialized! Start playing.
Basketball Game Started. Enjoy the game!
Basketball Game Finished!

4. 模板方法模式的优点

  • 代码复用：将算法的通用部分放在父类中实现，避免了重复代码的编写，增加了代码的复用性。
  • 灵活性：子类可以根据需要重写父类中的某些方法，灵活地定制算法的某些步骤，而不影响算法的整体结构。
  • 易于维护：算法的框架和步骤顺序在父类中实现，如果算法需要修改，只需修改父类中的代码，便可以影响到所有子类。
  • 遵循开闭原则：通过模板方法模式，算法的结构对修改关闭，但对扩展开放。子类可以通过扩展来改变算法的某些步骤，而不需要修改父类的代码。

5. 模板方法模式的缺点

  • 子类数量增加：每个不同的实现都需要创建一个子类，可能导致子类数量增加，增加了系统的复杂性。
  • 灵活性降低：由于算法的框架在父类中定义，子类不能轻易改变算法的整体结构，这在某些情况下可能会限制系统的灵活性。