java_template method

introduction:

模板方法模式：
在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
模板就是一个方法，这个方法将算法定义成一组步骤，其中的任何步骤都可以是抽象的，由子类负责实现。这可以确保算法的结构保持不变，同时由子类提供部分实现。

钩子是一种被申明在抽象类中的方法，但只有空的或者默认的实现。钩子的存在，让子类有能力对算法的不同点进行挂钩。要不要挂钩，由子类自行决定。

代码复用最大化
算法只存在于一个地方，容易修改
模板方法只专注于算法本身，而由子类提供完整实现

抽象方法与钩子：
当你的子类“必须”提供算法算法中某个方法或步骤的实现时，就使用抽象方法。
如果算法的这个部分是可选的，就用钩子。
某些方法是可选的，所以可以将这些步骤实现成钩子，而不是抽象方法。
钩子的用法：
1.钩子可以让子类实现可选的部分。
2.钩子能够有机会对模板中某些即将发生的步骤作出反应。

oo原则：

好莱坞原则：
别调用我们，我们会调用你。
高层组件会决定什么时候和怎样使用这些低层组件，高层组件对待低层组件的方式"别调用我们，我们会调用你"。
避免让高层组件和低层组件之间有明显的环状依赖。

好莱坞原则和依赖倒置原则：
1.依赖倒置原则：
多使用抽象，少使用具体。
避免在设计中出现依赖。
2.好莱坞原则：
让低层组件能够被挂钩进行计算中，而且不会让高层组件依赖低层组件。
高层组件和低层组件相互操作，又防止其他类太过依赖。

demo

1.模拟泡茶和咖啡场景

description:因为泡茶和咖啡的流程都是相似的，可以将这些流程封转为算法

CaffeineBeverage.java

public abstract class CaffeineBeverage {
    final void perpareRecipe(){
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }
    
    abstract void brew();
    abstract void addCondiments();
    
    void boilWater(){
        System.out.println("Boiling water");
    }
    
    void pourInCup(){
        System.out.println("Pouring into cup");
    }
    
}

Coffee.java

public class Coffee extends CaffeineBeverage{

    @Override
    void brew() {
        System.out.println("Dripping Coffee through filter");
    }

    @Override
    void addCondiments() {
        System.out.println("Adding Sugar and Milk");
    }

}

Tea.java

public class Tea extends CaffeineBeverage{

    @Override
    void brew() {
        System.out.println("Steeping the tea");
    }

    @Override
    void addCondiments() {
        System.out.println("Adding Lemon");
    }

}

Test.java

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

2.钩子方法

description:customerWantsCondiments就是钩子方法。

抽象方法与钩子：
当你的子类“必须”提供算法算法中某个方法或步骤的实现时，就使用抽象方法。
如果算法的这个部分是可选的，就用钩子。
某些方法是可选的，所以可以将这些步骤实现成钩子，而不是抽象方法。
钩子的用法：
1.钩子可以让子类实现可选的部分。
2.钩子能够有机会对模板中某些即将发生的步骤作出反应。

CaffeineBeverageWithHook.java

public abstract class CaffeineBeverageWithHook {
    final void perpareRecipe(){
        boilWater();
        brew();
        pourInCup();
        if(customerWantsCondiments()){
            addCondiments();
        }
    }
    
    abstract void brew();
    abstract void addCondiments();
    
    void boilWater(){
        System.out.println("Boiling water");
    }
    
    void pourInCup(){
        System.out.println("Pouring into cup");
    }
    
    boolean customerWantsCondiments(){
        return true;
    }
    
}

CoffeeWithHook.java

public class CoffeeWithHook extends CaffeineBeverageWithHook{

    @Override
    void brew() {
        System.out.println("Dripping Coffee through filter");
    }

    @Override
    void addCondiments() {
        System.out.println("Adding Sugar and Milk");
    }

    /* (non-Javadoc)
     * @see demo3.CaffeineBeverageWithHook#customerWantsCondiments()
     */
    @Override
    boolean customerWantsCondiments() {
        String answer = getUserInput();
        
        if(answer.toLowerCase().startsWith("y")){
            return true;
        }else{
            return false;
        }
    }
    
    public String getUserInput(){
        String answer = null;
        
        System.out.println("Would you like milk and sugar with your coffee (y/n)?");
        
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        
        try{
            answer = in.readLine();
        }catch(Exception e){
            System.out.println("IO　error trying to read your answer");
        }
        
        if(answer == null){
            return "no";
        }
        return answer;
    }
    
}

TeaWithHook.java

public class TeaWithHook extends CaffeineBeverageWithHook{

    @Override
    void brew() {
        System.out.println("Dripping tea through filter");
    }

    @Override
    void addCondiments() {
        System.out.println("Adding Lemon");
    }

    /* (non-Javadoc)
     * @see demo3.CaffeineBeverageWithHook#customerWantsCondiments()
     */
    @Override
    boolean customerWantsCondiments() {
        String answer = getUserInput();
        
        if(answer.toLowerCase().startsWith("y")){
            return true;
        }else{
            return false;
        }
    }
    
    public String getUserInput(){
        String answer = null;
        
        System.out.println("Would you like milk and sugar with your coffee (y/n)?");
        
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        
        try{
            answer = in.readLine();
        }catch(Exception e){
            System.out.println("IO　error trying to read your answer");
        }
        
        if(answer == null){
            return "no";
        }
        return answer;
    }

    
}

BeverageTestDrive.java

public class BeverageTestDrive {
    public static void main(String[] args) {
        TeaWithHook teaHook = new TeaWithHook();
        CoffeeWithHook coffeeWithHook = new CoffeeWithHook();
        
        System.out.println("\nMaking tea...");
        teaHook.perpareRecipe();
        
        System.out.println("\nMaking coffee...");
        coffeeWithHook.perpareRecipe();
    }
}

结果：

Making tea...
Boiling water
Dripping tea through filter
Pouring into cup
Would you like milk and sugar with your coffee (y/n)?
y
Adding Lemon


Making coffee...
Boiling water
Dripping Coffee through filter
Pouring into cup
Would you like milk and sugar with your coffee (y/n)?
n

模板方法和策略模式的区别：
1.模板方法：
通过继承的方式实现。
代码复用率高，可重复使用的代码都被放进超类中
定义一个算法的大纲，而由我的子类定义其中某些步骤的内容。
依赖性，相对于策略模式来说，是高的，因为子类需要依赖超类的方法。

2.策略模式：
通过对象组合的方式实现算法。
代码更有弹性。