设计模式-模板方法模式

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

在许多情况下，我们会遇到一些具有相似算法结构但具体实现步骤不同的问题。使用模板方法模式，我们可以将这些相似的算法结构整合在一个抽象类中，定义一个模板方法来描述算法的骨架，具体实现步骤则由子类来完成。

模板方法模式由以下角色组成：

1. 抽象类（Abstract Class）：抽象类定义了一个模板方法，该方法中包含了一系列的操作步骤，其中部分步骤由子类具体实现，部分步骤可以选择性地由子类实现（通过钩子方法控制）。抽象类还可以定义其他抽象方法或具体方法，用于辅助模板方法的实现。

2. 具体类（Concrete Class）：具体类继承自抽象类，实现了抽象类中定义的抽象方法，完成算法的具体步骤。

模板方法模式的工作原理如下：

1. 抽象类中定义一个模板方法，该方法中包含了一系列的操作步骤，并根据需求选择是否包含钩子方法。

2. 具体类继承抽象类，并实现抽象方法。

3. 客户端代码通过具体类调用模板方法，执行算法。

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

1. 封装不变的部分：将不变的算法结构封装在抽象类中，避免了代码重复。

2. 提取可变的部分：将可变的具体实现步骤延迟到子类中，使得算法的具体实现可以独立变化，提高了可扩展性和灵活性。

3. 提供了反向控制结构：通过在抽象类中定义钩子方法，子类可以选择性地实现或覆盖某些步骤，以改变算法的行为。

需要注意的是，模板方法模式主要适用于那些有一个不变的算法骨架，但其中的某些步骤具体实现可能不同的场景。在设计过程中，我们需要仔细考虑抽象类中的模板方法以及子类的具体实现步骤，确保算法的正确性和一致性。

以下是一个模板方法模式的示例代码：

// 抽象父类
abstract class AbstractClass {
    public void templateMethod() {
        // 操作步骤1
        step1();

        // 操作步骤2
        step2();

        // 钩子方法，子类可选择性实现
        if (hookMethod()) {
            // 操作步骤3
            step3();
        }

        // 操作步骤4
        step4();
    }

    public abstract void step1();
    public abstract void step2();
    public abstract void step3();
    public abstract void step4();

    // 钩子方法，默认为true，子类可选择性实现
    public boolean hookMethod() {
        return true;
    }
}

// 具体子类A
class ConcreteClassA extends AbstractClass {
    public void step1() {
        System.out.println("子类A：执行步骤1");
    }

    public void step2() {
        System.out.println("子类A：执行步骤2");
    }

    public void step3() {
        System.out.println("子类A：执行步骤3");
    }

    public void step4() {
        System.out.println("子类A：执行步骤4");
    }
}

// 具体子类B
class ConcreteClassB extends AbstractClass {
    public void step1() {
        System.out.println("子类B：执行步骤1");
    }

    public void step2() {
        System.out.println("子类B：执行步骤2");
    }

    public void step3() {
        System.out.println("子类B：没有实现步骤3");
    }

    public void step4() {
        System.out.println("子类B：执行步骤4");
    }

    public boolean hookMethod() {
        return false;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractClass classA = new ConcreteClassA();
        classA.templateMethod();

        System.out.println("---");

        AbstractClass classB = new ConcreteClassB();
        classB.templateMethod();
    }
}

在上述示例中，我们实现了模板方法模式的Java代码。

抽象父类 AbstractClass 定义了一个模板方法 templateMethod()，该方法中包含了一系列的操作步骤。

具体子类 ConcreteClassA 和 ConcreteClassB 继承自抽象父类，实现了父类中的抽象方法。

在客户端代码中，我们创建了具体子类的对象，并调用模板方法 templateMethod() 进行操作。在模板方法中，按照定义好的算法结构依次执行各个操作步骤，其中一些步骤由子类具体实现，而另一些步骤可以选择性地由子类实现（通过钩子方法控制）。

通过模板方法模式，我们将公共的算法结构封装在父类中，避免了代码重复，同时留出了一些具体的实现细节由子类自行实现。这样可以保持算法的一致性，同时提供了灵活性和可扩展性。