模板模式

1.利用多态将若干抽象方法组成一个步骤（称之为算法骨架结构），让子类具体实现。

2.代码：

C++

//template c++
#include <iostream>
using namespace std;

class Dog
{
public:
    virtual void introduce() = 0; 
    
};

class Alaska : public Dog{
    void introduce(){
        cout<<"Alaska is a huge dog,balabla..."<<endl;
    }
};

class Golden : public Dog{
    void introduce(){
        cout<<"Golden is a nice guy,balabla..."<<endl;
    }
};

int main(){
    Dog * p = NULL;
    p = new Alaska();
    p->introduce();
    delete p;
    
    p = new Golden();
    p->introduce();
    
    return 0;
}

 Java:

//template java 
import java.io.*;

abstract class CaffeineBeverageWithHook{
    void prepareRecipe(){
        boilWater();
        brew();
        pourInCup();
        if(customerWantsCondiments()){                //hook
            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;
    }
}

class CoffeeWithHook extends CaffeineBeverageWithHook{
    public void brew(){
        System.out.println("Dipping Coffee through filter");
    }
    public void addCondiments(){
        System.out.println("Adding Sugar and milk");
    }
    public boolean customerWantsCondiments(){
        String answer = getUserInput();
        if(answer.toLowerCase().startsWith("y")){
            return true;
        }else {
            return false;
        }
    }
    private String getUserInput(){
        String answer = null;
        System.out.print("Would you like milk and sugar add (y/n)?");
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        try{
            answer = in.readLine();
        }catch(IOException ioe){
            System.err.println("IO error");
        }
        if(null == answer)
            return "no";
        return answer;
    }
}

public class template{
    public static void main(String[] args){
        CoffeeWithHook coffeeHook = new CoffeeWithHook();
        System.out.println("Making coffee...");
        coffeeHook.prepareRecipe();
    }
}

 (2) 

//template duckComparable java
import java.util.Arrays;

class Duck implements Comparable{
    String name;
    int    weight;
    public Duck(String name,int weight){
        this.name   = name;
        this.weight = weight;
    }
    public String toString(){
        return name + " weights " + weight;
    }
    public int compareTo(Object object){
        Duck otherDuck = (Duck)object;
        if(this.weight < otherDuck.weight){
            return -1;
        }else if(this.weight == otherDuck.weight){
            return 0;
        }else {
            return 1;
        }
    }
}

public class duckComparable{
    public static void main(String[] args){
        Duck[] ducks = {
            new Duck("kaoya",4),
            new Duck("shaoya",6),
            new Duck("dunya",3),
            new Duck("zhaya",7)
        };
        System.out.println("Before sort:");
        display(ducks);
        
        Arrays.sort(ducks);
        
        System.out.println("\nAfter sort:");
        display(ducks);
    }
    public static void display(Duck[] ducks){
    for(Duck d : ducks)
        System.out.println(d);
    }
}

 3.杂记：

（1）好莱坞原则：高层组件对待低层组件，别调用我们，我们会调用你

（2）依赖倒置：依赖于抽象接口，不依赖于实现；A依赖virtual B；C1 extends B，C2 extends B；
         倒置（inverse）： 翻译比较坑，理解为换一种实现方式（思考方式）个人感觉更恰当。
（3）模板方法：结构不变，由子类实现算法中的某步骤，实例化；
         策略模式：封装可互换的行为，然后使用委托来决定要采用哪一个行为；
        通过对象组合让客户选择（算法族，族内可互换），有弹性，可在运行时改变
（4）钩子（hook）函数：if(a) {} void a(){return true;}
（5）steeping sea     浸泡
         brew                冲泡
         dripping coffee  滴流
         prepare recipe  食谱