设计模式教程：模板方法模式（Template Method Pattern）

一、概述

模板方法模式（Template Method Pattern） 是一种行为型设计模式，旨在定义一个操作中的算法骨架，而将一些步骤的具体实现延迟到子类中。通过模板方法模式，父类可以不改变算法结构的情况下，让子类重新定义某些步骤的实现，从而使得不同的子类可以有不同的行为。

模板方法模式适用于那些具有相同的整体流程但又希望子类可以在某些步骤上有所不同的场景。

二、模板方法模式的结构

模板方法模式主要包括以下几个角色：

1. AbstractClass（抽象类）
   • 作用：定义了一个模板方法，并实现了部分操作（通常是骨架结构）。模板方法中包含了不变的部分和调用其他方法的步骤。它通常会调用一些抽象方法，子类需要实现这些抽象方法。
   • 职责：提供一个模板方法，并且可以定义一些具体方法和抽象方法。
2. ConcreteClass（具体子类）
   • 作用：实现了抽象类中的抽象方法，用来具体实现模板方法中的某些步骤。
   • 职责：在模板方法中，具体的行为交给子类来实现，从而允许子类定制部分行为。
3. Template Method（模板方法）
   • 作用：在抽象类中定义的算法骨架方法。模板方法中包含了固定的步骤，并且可以调用部分抽象方法，这些抽象方法由子类实现，允许具体步骤的定制。

三、模板方法模式的优缺点

优点：

1. 复用性：模板方法模式将公共的算法骨架提取到父类中，使得子类只需要关注如何实现具体的步骤，避免了代码的重复，提高了代码复用性。
2. 灵活性：虽然模板方法定义了算法的骨架，但允许子类通过实现某些步骤来自定义行为，从而提高了灵活性。
3. 符合开闭原则：模板方法模式通过定义抽象类和子类，实现了对扩展开放，对修改关闭的设计。子类只需要实现特定的步骤，而不需要修改父类的模板方法。

缺点：

1. 过度依赖继承：模板方法模式使用了继承，因此子类必须遵循父类的骨架结构，可能导致某些代码过于耦合。
2. 增加了系统的复杂度：如果模板方法模式被过度使用，可能会导致系统中类的层次结构过于复杂，难以理解和维护。

四、模板方法模式的应用场景

模板方法模式适用于以下几种情况：

1. 算法流程固定，但某些步骤可以不同：当你有一个固定的操作流程，但其中某些步骤的实现可能因不同子类的需求而有所变化时，模板方法模式非常适用。
2. 多个子类有相同的执行流程：当多个子类需要执行相同的步骤时，可以将公共的步骤提取到父类中，避免代码重复。
3. 封装不变部分，扩展可变部分：当操作的某些步骤不变，而其他步骤可以根据具体子类的需求来变更时，模板方法模式可以很好地实现封装与扩展的需求。

五、模板方法模式的实现

为了更好地理解模板方法模式，下面通过一个简单的例子来展示其实现。假设我们要实现一个“制作饮品”的过程，制作饮品的过程大致相同，但不同饮品的具体制作步骤有所不同。

1. 定义抽象类

我们首先定义一个抽象类 Beverage，它包含一个 prepareRecipe() 的模板方法，定义了制作饮品的骨架流程。模板方法中调用了几个抽象方法，这些方法在子类中实现，用于定制具体步骤。

public abstract class Beverage {
    
    // 模板方法
    public final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    // 公共步骤，所有饮品都需要煮水
    private void boilWater() {
        System.out.println("煮水");
    }

    // 抽象方法，具体的冲泡方式由子类实现
    protected abstract void brew();

    // 公共步骤，所有饮品都需要倒入杯中
    private void pourInCup() {
        System.out.println("倒入杯中");
    }

    // 抽象方法，具体的调味由子类实现
    protected abstract void addCondiments();
}

2. 定义具体子类

接下来，我们定义两个具体的饮品类 Tea 和 Coffee，它们分别实现了 brew() 和 addCondiments() 方法来定制不同的冲泡和调味方式。

// 具体子类：茶
public class Tea extends Beverage {

    @Override
    protected void brew() {
        System.out.println("用热水泡茶叶");
    }

    @Override
    protected void addCondiments() {
        System.out.println("添加柠檬");
    }
}

// 具体子类：咖啡
public class Coffee extends Beverage {

    @Override
    protected void brew() {
        System.out.println("用热水冲泡咖啡");
    }

    @Override
    protected void addCondiments() {
        System.out.println("添加糖和牛奶");
    }
}

3. 使用模板方法

在 Main 方法中，我们可以看到不同饮品的制作过程如何通过模板方法来完成。

public class Main {
    public static void main(String[] args) {
        Beverage tea = new Tea();
        tea.prepareRecipe();  // 制作茶的过程
        
        System.out.println("------------");
        
        Beverage coffee = new Coffee();
        coffee.prepareRecipe();  // 制作咖啡的过程
    }
}

4. 输出结果

煮水
用热水泡茶叶
倒入杯中
添加柠檬
------------
煮水
用热水冲泡咖啡
倒入杯中
添加糖和牛奶

六、深入分析

在这个例子中，Beverage 类作为抽象类，定义了一个模板方法 prepareRecipe()，它包含了制作饮品的公共步骤，如煮水、倒入杯中等。具体的步骤如冲泡和调味，由子类 Tea 和 Coffee 来实现，从而实现了流程的灵活定制。

为什么使用模板方法模式？

• 复用和扩展性：通过将公共的操作提取到父类中，子类只需要关注具体的步骤，不需要重复实现公共操作。这提高了代码的复用性，同时也方便了扩展新的饮品类型。
• 结构清晰：模板方法模式通过统一的流程定义，使得整个算法的结构非常清晰，避免了代码的重复，并且让修改和扩展更加方便。

七、模板方法模式与其他设计模式的比较

1. 模板方法模式 vs 策略模式

• 模板方法模式：定义了算法的骨架，某些具体步骤留给子类实现，适用于那些流程固定但部分步骤需要定制的情况。
• 策略模式：定义了一系列算法，并将它们封装到独立的策略类中，适用于需要根据不同情况选择不同算法的场景。

模板方法模式是结构化的，算法骨架已经固定，而策略模式则是将算法抽象出来，可以动态替换。

2. 模板方法模式 vs 观察者模式

• 模板方法模式：主要通过继承来重写某些步骤，适用于固定流程中的定制化。
• 观察者模式：通过事件发布和订阅机制，让对象之间解耦，适用于一对多的通知场景。

两者的核心区别在于：模板方法模式专注于定制化流程，而观察者模式更侧重于解耦和事件驱动。

八、总结

模板方法模式通过在父类中定义算法的骨架，将一些步骤的实现推迟到子类中，从而使得算法的整体结构得到复用，并且允许子类灵活定制部分行为。它提高了代码的复用性、可扩展性和维护性，特别适用于那些算法骨架固定，而某些步骤可能发生变化的场景。

但是，模板方法模式也有一些限制，如过度依赖继承可能导致子类之间耦合性较强。总体来说，模板方法模式是一种非常实用的设计模式，适用于多个子类有相同的执行流程，且某些步骤需要根据不同情况进行定制的

版权声明

1. 本文内容属于原创，欢迎转载，但请务必注明出处和作者，尊重原创版权。
2. 转载时，请附带原文链接并注明“本文作者：扣丁梦想家
3. 禁止未经授权的商业转载。

如果您有任何问题或建议，欢迎留言讨论。