行為型模式又可以分成以下四類：第一類：通過父類與子類的關係進行實現。第二類：兩個類之間。第三類：類的狀態。第四類：通過中間類

　　模板方法模式屬於第一類，父類與子類的關係

　　定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中。 模板方法使得子類可以不改變一個演算法的結構即可重定義該演算法的某些特定步驟。

　　模板類中可包含要實現的模板方法，還可以包含基本方法，基本方法分三類

　　(1) 抽象方法：一個抽象方法由抽象類宣告、由其具體子類實現。在C#語言裡一個抽象方法以abstract關鍵字標識。

       (2)

       (3) 鉤子方法：一個鉤子方法由一個抽象類或具體類宣告並實現，而其子類可能會加以擴充套件。通常在父類中給出的實現是一個空實現（可使用virtual關鍵字將其定義為虛擬函式），並以該空實現作為方法的預設實現，當然鉤子方法也可以提供一個非空的預設實現。在模板方法模式中，鉤子方法有兩類：第一類鉤子方法可以與一些具體步驟“掛鉤”，以實現在不同條件下執行模板方法中的不同步驟，這類鉤子方法的返回型別通常是bool型別的，這類方法名一般為IsXXX()，用於對某個條件進行判斷，如果條件滿足則執行某一步驟，否則將不執行；還有一類鉤子方法就是實現體為空的具體方法

　　下面再來看運算的例子

    package behavior.pattern.extend.templatemethod;

public abstract class AbstractCalculator {
    /* main method */
    public final void mainCaculate(String exp)
    {
        int result = calculate(exp);
        
 
if(isPrint())
            print(exp, result);
        other(result);
    }
    
    /* control method */
    protected boolean isPrint()
    {
        return true;
    }

    /* abstract steps */
    protected abstract int calculate(String exp);
    protected abstract void print(String exp, int result);
    protected abstract void other(int result);
    
    /* assistant method */
    public int[] split(String exp,String opt){  
        String array[] = exp.split(opt);  
        int arrayInt[] = new int[2];  
        arrayInt[0] = Integer.parseInt(array[0]);  
        arrayInt[1] = Integer.parseInt(array[1]);  
        return arrayInt;  
    }
}

package behavior.pattern.extend.templatemethod;

public class Minus extends AbstractCalculator {

    private boolean isPrint;

    public Minus(boolean isPrint) {
        this.isPrint = isPrint;
    }

    @Override
    public int calculate(String exp) {
        int[] split = split(exp, "-");
        return split[0] - split[1];
    }

    @Override
    protected void print(String exp, int result) {
        System.out.println("the minus result: " + exp + " = " + result);
    }

    @Override
    protected boolean isPrint() {
        return isPrint;
    }

    @Override
    protected void other(int result) {
        System.out.println("other...");
    }
}

package behavior.pattern.extend.templatemethod;

public class Plus extends AbstractCalculator {

    private boolean isPrint;
    @Override
    public int calculate(String exp) {
        int[] split = split(exp, "+");
        return split[0] - split[1];
    }

    @Override
    protected void print(String exp, int result) {
        System.out.println("the plus result: " + exp + " = " + result);
    }

    @Override
    protected boolean isPrint() {
        return isPrint;
    }
    
    @Override
    protected void other(int result) {
        System.out.println("other...");
    }
}

package behavior.pattern.extend.templatemethod;

public class Multiply extends AbstractCalculator {

    private boolean isPrint;
    
    public Multiply(boolean isPrint) {
        this.isPrint = isPrint;
    }

    @Override
    public int calculate(String exp) {
        int[] split = split(exp, "*");
        return split[0] - split[1];
    }

    @Override
    protected void print(String exp, int result) {
        System.out.println("the multiply result: " + exp + " = " + result);
    }

    @Override
    protected boolean isPrint() {
        return isPrint;
    }
    
    @Override
    protected void other(int result) {
        System.out.println("other...");
    }
}

　　測試程式碼

package behavior.pattern.extend.templatemethod;

public class Client {
    public static void main(String[] args) {
        AbstractCalculator minus = new Minus(true);
        minus.mainCaculate("43536363-1155145");
    }
}

　　執行結果