模板设计模式

设计模式：解耦，第三方

开闭原则（OCP）：一个软件实体如类、模块或函数应该对扩展开放，对修改关闭。

模板设计模式：基于抽象类

定义：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，模板设计模式可以使得子类在不改变算法的前提下，重新定义算法中的某些步骤。

模板超类的定义：

1. 基类声明为抽象类（子类具体实现）

2. 模板方法被声明称final,以免子类改变这个算法顺序

3. 具体操作延迟到子类中实现（基类中的abstact方法）

4.  具体操作且共用的方法定义在超类中，可以被模板方法或子类直接使用，声明称final方法

5. 钩子方法，默认不做事的方法，子类可以视情况决定要不要覆写。

例：冲咖啡

1.烧水

2.用水冲泡咖啡

3.把咖啡倒入杯中

4.加糖或者牛奶

例：泡茶

1.烧水

2.浸泡茶叶

3.把茶倒入杯中

4.加柠檬

我们在这两个类中发现了重复部分，因此我们需要重新整理一下我们的设计。

既然茶和咖啡是如此的相似，因此我们应该将共同的部分抽取出来，放进一个基类中。

abstract class CaffeineBeverage{
    //核心冲泡法
    //封装算法
    final void prepareRecipe(){
        boilWater();
        brew();
        pourInCup();
        if(customerWantsCondiments())
        {
            addCondiments();
        }

    }
    final void boilWater(){
        System.out.println("将水烧开");
    }
    final void pourInCup(){
        System.out.println("将饮料倒入杯中");
    }
    abstract void brew();
    abstract void addCondiments();
    //钩子方法
    boolean customerWantsCondiments(){
        return true;
    }
}
class Coffee extends CaffeineBeverage{
    void brew(){
        System.out.println("冲泡咖啡");
    }
    void addCondiments(){
        System.out.println("加牛奶或糖");
    }
}
class Tea extends CaffeineBeverage{
    void brew(){
        System.out.println("浸泡茶叶");
    }
    void addCondiments(){
        System.out.println("加柠檬");
    }
    boolean customerWantsCondiments(){
        System.out.println("请问您需要加柠檬吗？y/n");
        String result = getUserInfo();
        if(result.equals("y")){
            return true;
        }else{
            return false;
        }
    }
    //询问用户是否加调料
    private String getUserInfo(){
        String str = null;
        Scanner scanner = new Scanner(System.in);
        str = scanner.nextLine();
        return str;
    }
}
public class Test{
    public static void main(String[] args) {
        CaffeineBeverage coffee = new Coffee();
        coffee.prepareRecipe();
        CaffeineBeverage tea = new Tea();
        tea.prepareRecipe();
    }
}