模板模式

1. 概念

模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

2. 作用

在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中实现。模板方法使得子类在不改变算法结构的情况下，重新定义算法中的某些步骤。

3. 适用场景

在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异

4. 示例

屏幕快照 2021-01-17 下午12.41.07.png
例1不使用钩子的模板模式
抽象方法：CaffeineBeverage

public abstract class CaffeineBeverage {
     // 组装好整体的流程，子类不要覆盖
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }
    public abstract void addCondiments();
    public abstract void brew();
    private void boilWater() {
        System.out.println("Boiling water");
    }
    private void pourInCup() {
        System.out.println("Pouring into cup");
    }
}

具体类1：

public class Coffee extends CaffeineBeverage {
    @Override
    public void addCondiments() {
        System.out.println("Adding Sugar and Milk");
    }
    @Override
    public void brew() {
        System.out.println("Dripping coffee through filter");
    }
}

具体类2：

public class Tea extends CaffeineBeverage {
    @Override
    public void addCondiments() {
        System.out.println("Adding Lemon");
    }
    @Override
    public void brew() {
        System.out.println("Steeping the tea");
    }
}

场景类：

public class Test {
    public static void main(String[] args) {
        Tea tea = new Tea();
        tea.prepareRecipe();
        System.out.println("\n");
        Coffee coffee = new Coffee();
        coffee.prepareRecipe();
    }
}

例2 使用钩子的模板模式
模板方法抽象类：

public abstract class CaffeineBeverageWithHook {
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }
    public abstract void addCondiments();
    public abstract void brew();
    private void boilWater() {
        System.out.println("Boiling water");
    }
    private void pourInCup() {
        System.out.println("Pouring into cup");
    }
    /*
    我们在这里定义一个方法，（通常）是空的缺省实现。
    “空的缺省实现”这句话的意思是，首先“缺省”的意思是“默认”的意思，所以这句话的意思是定义一个默认不做任何事情的方法
    这就是一个钩子，子类可以选择覆盖这个方法，也可以选择不覆盖（即默认）
     */
    public boolean customerWantsCondiments() {
        return true;
    }
}

具体类：

public class CoffeeWithHook extends CaffeineBeverageWithHook {
    @Override
    public void addCondiments() {
        System.out.println("Adding Sugar and Milk");
    }
    @Override
    public void brew() {
        System.out.println("Dripping coffee through filter");
    }
    @Override
    public boolean customerWantsCondiments() {
        String answer = getUserInput();
        if (answer.toLowerCase().equals("y")) {
            return true;
        } else
            return false;
    }
    private String getUserInput() {
        String answer = null;
        System.out
                .println("Would you like sugar and milk with your caffee(y/n)?");
        BufferedReader bis = new BufferedReader(
                new InputStreamReader(System.in));
        try {
            answer = bis.readLine();
        } catch (Exception e) {
            System.err.println("IO error ,try to read your answer");
        }
        if (answer == null||answer.equals("")) {
            return "no";
        }
        return answer;
    }
}

那么，钩子到底是什么作用？
钩子可以让子类选择是否实现算法中的可选部分。

5. 总结

• 优点

1. 父类封装不变部分，子类扩展可变部分
2. 提取公共代码，便于维护

• 缺点
  每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大
• 注意

1. 钩子是一个方法，他在抽象类中不做事，或者只做默认的事情，子类可以选择是否重写这个钩子方法。
2. 为了防止子类修改覆盖抽象类中的模板方法，可以将模板方法设置为final。
3. 策略模式和模板模式都封装了算法，只是它们的实现方式不同，策略模式使用的是组合，模板模式使用的是继承。

————————————————————
坐标帝都，白天上班族，晚上是知识的分享者
如果读完觉得有收获的话，欢迎点赞加关注