23种设计模式-模板方法(Template Method)设计模式

文章目录

一.什么是模板方法模式？
二.模板方法模式的特点
三.模板方法模式的结构
四.模板方法模式的应用场景
五.模板方法模式的优缺点
六.模板方法模式的C++实现
七.模板方法模式的JAVA实现
八.代码解析
九.总结

类图：模板方法设计模式类图

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

模板方法模式 （Template Method Pattern）是一种行为型设计模式，它定义了一个操作中的算法骨架，而将一些步骤的实现延迟到子类中。通过这种方式，模板方法允许子类在不改变算法结构的情况下重新定义某些步骤的具体实现。

二.模板方法模式的特点

算法骨架固定：整体流程在父类中定义，子类只需实现特定步骤。
代码复用：通用的算法步骤可以在父类中实现，避免重复代码。
扩展灵活：新增子类时，只需重写相关步骤，无需修改已有代码。

三.模板方法模式的结构

AbstractClass（抽象类） ：
- 定义算法的骨架（TemplateMethod），包括一系列步骤（PrimitiveOperation）。
- 部分步骤由子类实现（抽象方法）。
ConcreteClass（具体类） ：
- 实现抽象类定义的抽象方法。
- 可以根据需要扩展或修改步骤的具体实现。

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

多个子类有共同行为逻辑，但具体实现不同。
固定的流程需要扩展某些步骤。
避免重复代码，提取通用逻辑。

五.模板方法模式的优缺点

优点：
- 提高代码复用性。
- 强制遵循一致的算法框架。
- 易于维护和扩展。
缺点：
- 子类数目较多时，代码可能变得复杂。
- 设计要求较高，需要仔细分析算法流程。

六.模板方法模式的C++实现

cpp 复制代码

#include <iostream>
using namespace std;

// 抽象类 AbstractClass
class AbstractClass {
public:
    // 模板方法，定义算法骨架
    void TemplateMethod() {
        PrimitiveOperation1(); // 第一步
        PrimitiveOperation2(); // 第二步
        Hook();                // 钩子方法（可选）
    }

    // 基本操作，子类必须实现
    virtual void PrimitiveOperation1() = 0;
    virtual void PrimitiveOperation2() = 0;

    // 钩子方法，子类可以选择性重写
    virtual void Hook() {
        cout << "AbstractClass: Default Hook implementation.\n";
    }

    virtual ~AbstractClass() = default;
};

// 具体类 ConcreteClass
class ConcreteClass : public AbstractClass {
public:
    void PrimitiveOperation1() override {
        cout << "ConcreteClass: Implementing PrimitiveOperation1.\n";
    }

    void PrimitiveOperation2() override {
        cout << "ConcreteClass: Implementing PrimitiveOperation2.\n";
    }

    void Hook() override {
        cout << "ConcreteClass: Overriding Hook method.\n";
    }
};

// 客户端代码
int main() {
    cout << "Using Template Method Pattern:\n";
    AbstractClass* obj = new ConcreteClass();
    obj->TemplateMethod(); // 调用模板方法
    delete obj;
    return 0;
}

七.模板方法模式的JAVA实现

java 复制代码

// 抽象类
abstract class AbstractClass {
    // 模板方法
    public final void TemplateMethod() {
        PrimitiveOperation1();
        PrimitiveOperation2();
    }

    // 抽象基本操作（必须由子类实现）
    protected abstract void PrimitiveOperation1();
    protected abstract void PrimitiveOperation2();
}

// 具体类A
class ConcreteClassA extends AbstractClass {
    @Override
    protected void PrimitiveOperation1() {
        System.out.println("ConcreteClassA: Performing PrimitiveOperation1");
    }

    @Override
    protected void PrimitiveOperation2() {
        System.out.println("ConcreteClassA: Performing PrimitiveOperation2");
    }
}

// 具体类B
class ConcreteClassB extends AbstractClass {
    @Override
    protected void PrimitiveOperation1() {
        System.out.println("ConcreteClassB: Performing PrimitiveOperation1");
    }

    @Override
    protected void PrimitiveOperation2() {
        System.out.println("ConcreteClassB: Performing PrimitiveOperation2");
    }
}

// 客户端代码
public class TemplateMethodPatternDemo {
    public static void main(String[] args) {
        // 使用 ConcreteClassA
        AbstractClass classA = new ConcreteClassA();
        System.out.println("ConcreteClassA Template Method Execution:");
        classA.TemplateMethod();

        // 使用 ConcreteClassB
        AbstractClass classB = new ConcreteClassB();
        System.out.println("\nConcreteClassB Template Method Execution:");
        classB.TemplateMethod();
    }
}

八.代码解析

抽象类 ：
- TemplateMethod() 是模板方法，定义了算法的执行顺序。
- PrimitiveOperation1 和 PrimitiveOperation2 是抽象方法，具体实现由子类完成。
- Hook 是钩子方法，提供默认实现，子类可以选择性重写。
具体类 ：
- ConcreteClass 实现了抽象类的抽象方法，并可根据需要覆盖钩子方法。
客户端代码 ：
- 创建一个具体类的实例，通过抽象类指针调用模板方法。

九.总结

模板方法模式通过定义一个算法的通用骨架，为子类提供了灵活的扩展点。它适用于多个子类具有相似逻辑但部分实现不同的场景。通过这种模式，代码的复用性和扩展性得到了极大提升，同时保证了算法逻辑的一致性。