设计模式-模板方法模式

模板方法模式（Template Method）

• 动机：对于一项任务，常常有稳定的整体操作结构，但各个子步骤却又很多改变的需求，或者需要子步骤的晚期实现（延迟到子类去实现）。
• Template Method使得子类可以复用一个算法的结构（Override 重写）该算法的某些特定步骤。
• 不要调用我，让我来调用你，实现晚绑定机制，这也就是控制反转的思想。
• 声明成 protected ,因为具体步骤在流程中才有意义。

• AbstractClass : 稳定的骨架（里面有具体的方法和需要被重写的方法）
• ContreteClass : 具体的重写方法

模板方法模式定义（特别的常用）：

• 定义一个操作中的算法的骨架（稳定） ,而将一些步骤（变化）延迟到子类中。
• Template Method 使得子类可以不改变（复用）一个算法的结构即可（Override 重写）该算法某些特定的步骤

• 具体实现（举例）

冲咖啡和冲茶都有类似的流程，但是某些步骤会有点不一样，要求复用那些相同步骤的代码。

public abstract class AbstractClass {

    // 骨架流程
    final void prepareRecipe(){
        boilWater();
        brew();
        pourIncoup();
        addCondiments();
    }

    // 待重写的方法
    abstract void brew();

    // 待重写的方法
    abstract void addCondiments();


    void pourIncoup() {
        System.out.println("倒进杯子");
    }

    void boilWater() {
        System.out.println("倒水");
    }

}

public class Coffee extends AbstractClass {
    void brew() {
        System.out.println("倒咖啡");
    }

    void addCondiments() {
        System.out.println("加入咖啡粉");
    }
}

public class Tea extends AbstractClass {
    void brew() {
        System.out.println("倒茶");
    }

    void addCondiments() {
        System.out.println("加入茶叶");
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractClass coffee = new Coffee();
        coffee.prepareRecipe();

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


        AbstractClass tea = new Tea();
        tea.prepareRecipe();
    }
}

结果显示：

倒水
倒咖啡
倒进杯子
加入咖啡粉
========
倒水
倒茶
倒进杯子
加入茶叶

JDK中实现：

• java.util.Collections#sort()
• java.io.InputStream#skip()
• java.io.InputStream#read()
• java.util.AbstractList#indexOf()

打赏