设计模式- 模板方法模式（Template Method Pattern） 结构|原理|优缺点|场景|示例

                                     设计模式（分类）        设计模式（六大原则）   

    创建型（5种）        工厂方法         抽象工厂模式        单例模式        建造者模式        原型模式

    结构型（7种）        适配器模式        装饰器模式        代理模式        ​​​​​​外观模式      桥接模式        组合模式       享元模式

    行为型（11种）      策略模式        模板方法模式        观察者模式        迭代器模式        责任链模式        命令模式

                                   备忘录模式          状态模式          访问者模式        中介者模式

---

模板方法模式（Template Method Pattern）是一种行为型设计模式，用于定义一个算法的骨架，而将一些步骤的具体实现延迟到子类中。这样，可以在不改变算法结构的情况下，让子类重新定义算法中的某些步骤。

主要角色：

1. 抽象类（Abstract Class）：定义一个模板方法（Template Method），其中包含算法的框架，以及一些抽象方法或具体方法。抽象类中的模板方法定义了算法的步骤顺序，并调用了具体的方法，这些方法可以是抽象的，由子类去实现。

2. 具体子类（Concrete Class）：继承自抽象类，实现了其中定义的抽象方法，提供了算法中特定步骤的具体实现。具体子类可以覆盖抽象类中的方法，以实现特定的行为。

工作原理：

1. 抽象类定义了一个模板方法，其中包含了算法的骨架，以及一些抽象方法或具体方法。
2. 具体子类继承抽象类，并实现其中的抽象方法，提供算法中特定步骤的具体实现。
3. 客户端通过调用抽象类中的模板方法来使用算法，具体子类会按照模板方法定义的算法框架执行相应的步骤。

优点：

• 提高代码复用性：通过抽象模板方法，封装了算法的通用部分，使得代码更易于维护和扩展。
• 灵活性：允许子类根据需要重新定义或扩展算法中的特定步骤，从而实现定制化。
• 便于管理：通过模板方法对算法进行统一管理和调度，提高了代码的结构化程度。

缺点：

• 可能导致代码膨胀：如果模板方法中的步骤过多或过于复杂，会增加子类的实现难度，导致代码膨胀。
• 限制灵活性：模板方法模式可能限制了子类的灵活性，特定步骤的实现必须符合父类定义的算法框架。

适用场景：

模板方法模式适用于以下场景：

• 当需要实现一组算法中的共同部分，并将可变部分延迟到子类中时。
• 当存在多个具有相似算法结构但实现细节不同的情况时。
• 当希望通过一个固定的算法框架来管理和调度算法时。

代码示例（以Java为例）

// 抽象类定义了算法框架
abstract class AbstractClass {
    // 模板方法定义了算法的骨架，调用了具体的方法
    public void templateMethod() {
        step1();
        step2();
        step3();
    }
    
    // 具体方法，有默认实现
    protected void step1() {
        System.out.println("AbstractClass: Performing step 1");
    }
    
    // 抽象方法，由子类实现
    protected abstract void step2();
    
    // 具体方法，可以在子类中选择是否覆盖
    protected void step3() {
        System.out.println("AbstractClass: Performing step 3");
    }
}
 
// 具体子类实现了抽象类中的抽象方法
class ConcreteClass extends AbstractClass {
    // 实现了抽象方法
    @Override
    protected void step2() {
        System.out.println("ConcreteClass: Performing step 2");
    }
}
 
public class Main {
    public static void main(String[] args) {
        // 创建具体子类对象
        AbstractClass obj = new ConcreteClass();
        // 调用模板方法
        obj.templateMethod();
    }
}

代码示例（以Python为例）

from abc import ABC, abstractmethod
 
# 抽象类定义了算法框架
class AbstractClass(ABC):
    # 模板方法定义了算法的骨架，调用了具体的方法
    def template_method(self):
        self.step1()
        self.step2()
        self.step3()
    
    # 具体方法，有默认实现
    def step1(self):
        print("AbstractClass: Performing step 1")
    
    # 抽象方法，由子类实现
    @abstractmethod
    def step2(self):
        pass
    
    # 具体方法，可以在子类中选择是否覆盖
    def step3(self):
        print("AbstractClass: Performing step 3")
 
# 具体子类实现了抽象类中的抽象方法
class ConcreteClass(AbstractClass):
    # 实现了抽象方法
    def step2(self):
        print("ConcreteClass: Performing step 2")
 
if __name__ == "__main__":
    # 创建具体子类对象
    obj = ConcreteClass()
    # 调用模板方法
    obj.template_method()

在这个示例中，AbstractClass 是抽象类，定义了模板方法 templateMethod() 和具体方法 step1()、step3()，以及抽象方法 step2()。ConcreteClass 是具体子类，实现了抽象方法 step2()。在 Main 类中，我们创建了 ConcreteClass 的对象，并调用了模板方法 templateMethod()，它按照定义的算法骨架执行了相应的步骤。