模板模式

模板模式的主要目的是定义一个算法的框架，将算法的具体实现延迟到子类中。通过使用模板模式，我们可以在不改变算法结构的情况下，通过重写部分步骤的方式来定制算法的特定行为。

在实际应用中，模板模式非常适用于实现算法的变体和算法的复用。通过定义一个模板方法，在这个方法中定义了算法的骨架，固定了算法的执行顺序和结构，并且通过抽象方法或者钩子方法来将可变部分留给子类实现。

下面是一个简单的Java示例，展示了如何使用模板模式：

public abstract class AbstractClass {
    public final void templateMethod() {
        // 这里是算法的骨架，定义了算法的执行顺序和结构
        // 步骤1
        step1();
        // 步骤2
        step2();
        // 钩子方法，可选的具体实现，由子类决定是否覆盖
        if (hookMethod()) {
            // 步骤3
            step3();
        }
        // 步骤4
        step4();
    }
    protected abstract void step1();
    protected abstract void step2();
    protected boolean hookMethod() {
        return true;
    }
    protected abstract void step3();
    protected abstract void step4();
}
public class ConcreteClassA extends AbstractClass {
    @Override
    protected void step1() {
        System.out.println("ConcreteClassA: Step 1");
    }
    @Override
    protected void step2() {
        System.out.println("ConcreteClassA: Step 2");
    }
    @Override
    protected void step3() {
        System.out.println("ConcreteClassA: Step 3");
    }
    @Override
    protected void step4() {
        System.out.println("ConcreteClassA: Step 4");
    }
}
public class ConcreteClassB extends AbstractClass {
    @Override
    protected void step1() {
        System.out.println("ConcreteClassB: Step 1");
    }
    @Override
    protected void step2() {
        System.out.println("ConcreteClassB: Step 2");
    }
    @Override
    protected boolean hookMethod() {
        return false;
    }
    @Override
    protected void step3() {
        System.out.println("ConcreteClassB: Step 3");
    }
    @Override
    protected void step4() {
        System.out.println("ConcreteClassB: Step 4");
    }
}
public class TemplatePatternDemo {
    public static void main(String[] args) {
        AbstractClass templateA = new ConcreteClassA();
        System.out.println("Running ConcreteClassA:");
        templateA.templateMethod();
        System.out.println();
        AbstractClass templateB = new ConcreteClassB();
        System.out.println("Running ConcreteClassB:");
        templateB.templateMethod();
    }
}

在这个示例中，AbstractClass是模板类，它定义了算法的骨架，其中的templateMethod()是模板方法。步骤1、2、4是必须的，而步骤3是一个钩子方法，子类可以选择是否覆盖它。

ConcreteClassA和ConcreteClassB是具体的子类，它们分别实现了抽象方法step1、step2、step3、step4，并且覆盖了钩子方法hookMethod()。通过继承AbstractClass并实现具体的方法，它们定制了算法的具体行为。

在模板模式中，算法的骨架是固定的，但具体的实现可以根据需求定制。这种方式可以让算法的框架具备可复用性，同时也提供了灵活性，因为具体步骤的实现可以在子类中进行定制。