模板方法模式的理解和使用

一、是什么

1. 定义: 在一个方法中定义一个算法的骨架，将一些步骤延迟到子类中实现

2. 好处:

　　代码复用,  对于某些算法的实现时，很有效，确定了整体的架子，让子类去实现具体的步骤

二、示例

1. 代码背景:

• 制作茶的步骤是：
  • 1. 把水煮沸
  • 2.用沸水浸泡茶叶
  • 3. 把冲泡的倒进杯子
  • 4. 加柠檬
• 制作咖啡的步骤：
  • 1. 把水煮沸
  • 2. 冲泡 
  • 3. 把冲泡的倒进杯子
  • 4. 加糖和牛奶

比较发现 1. 3步骤是很相似的，2,4步骤不同，所以我们可以提取中抽象类

2. 饮料制作抽象类，定义冲泡的步骤

prepareBecipe()方法将冲泡的步骤定义好了，有些具体的步骤的实现交给子类去做，这里用final关键字，告诉别人，我的步骤已经定了，你们别改

/**
 * 饮料制作
 */
public abstract class CaffeineBeverage {

    /**
     * 准备饮料 设置这个方法不更改
     */
    public final void prepareBecipe() {
        // 1.把水煮沸
        boilWater();

        // 2. 泡: 将具体实现延迟到子类中
        brew();

        // 3. 把茶倒进杯子
        pourInCup();

        // 4. 加调料: 将具体实现延迟到子类中
        addCondiments();
    }

    /**
     * 2. 泡
     */
    abstract void brew();

    /**
     * 4. 加调料
     */
    abstract void addCondiments();

    void boilWater() {
        System.out.println("把水煮沸");
    }

    void pourInCup() {
        System.out.println("把冲泡的倒进杯子");
    }
}

3. 定义茶、咖啡子类

/**
 * 泡茶
 */
public class Tea extends CaffeineBeverage {
    @Override
    void brew() {
        System.out.println("用沸水冲茶叶");
    }

    @Override
    void addCondiments() {
        System.out.println("加柠檬");
    }
}

/**
 * 咖啡
 */
public class Coffee extends CaffeineBeverage{

    @Override
    void brew() {
        System.out.println("用沸水冲泡咖啡");
    }

    @Override
    void addCondiments() {
        System.out.println("加糖和牛奶");
    }
}

4. 测试类

/**
 * 测试类
 */
public class Main {

    public static void main(String[] args) {
        Tea tea = new Tea();
        tea.prepareBecipe();

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

        Coffee coffee = new Coffee();
        coffee.prepareBecipe();
    }
}

// 控制台显示
把水煮沸
用沸水冲茶叶
把冲泡的倒进杯子
加柠檬
=====================================
把水煮沸
用沸水冲泡咖啡
把冲泡的倒进杯子
加糖和牛奶

三、总结

1）具体细节步骤实现定义在子类中，子类定义详细处理算法是不会改变算法整体结构。

2）使用的是继承