模板方法模式

模板方法模式（template）：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法的某些步骤。
通俗来讲：在父类的某个方法中定义了整个算法的骨架（就是这个调用各个方法的逻辑顺序），而将具体实现这一个算法的一些方法延迟到子类来实现（父类中仅有这个方法名，没有具体内容）。

模板方法模式结构图

喝咖啡和喝茶的例子

package com.template;
/**
 * ClassName: AbstractClass 
 * @Description:抽象父类 
 * @author Panyk
 * @date 2016年3月9日
 */
public abstract class AbstractClass {
    /**
     * @Description:封装的算法模块。
     * 有了该算法模块，我们不需要调用细节方法，只需要调用该算法模块就能使用一系列的功能。
     * （之所以是final为了防止子类重写该方法） 
     * @param    
     * @return void  
     * @throws
     * @author Panyk
     * @date 2016年3月9日
     */
    final void templateMethod(){
        this.boil();
        this.brew();
        this.pourIntoCup();
        if(this.hook()){
            this.addCondiments();
        }
    }
    /**
     * @Description:冲咖啡或者是泡茶 
     * @param    
     * @return void  
     * @throws
     * @author Panyk
     * @date 2016年3月9日
     */
    abstract void brew();
    /**
     * @Description:添加调料 
     * @param    
     * @return void  
     * @throws
     * @author Panyk
     * @date 2016年3月9日
     */
    abstract void addCondiments();
    
    private void boil(){}{
        System.out.println("烧开水！");
    }
    private void pourIntoCup(){
        System.out.println("倒进杯子中！");
    }
    /**
     * @Description:钩子方法，默认返回true，表示添加调料。
     * @param @return   
     * @return boolean  
     * @throws
     * @author Panyk
     * @date 2016年3月9日
     */
    protected boolean hook(){
        return true;
    }
}

package com.template;

public class Coffee extends AbstractClass {
    /**
     * 抽象方法子类必须实现
     */
    @Override
    protected void brew() {
        System.out.println("冲咖啡！");
    }
    @Override
    protected void addCondiments() {
        System.out.println("添加糖和牛奶！");
    }
    @Override
    protected boolean hook() {
        System.out.println("钩子返回咖啡加调料！");
        return true;
    }
}

package com.template;

public class Tea extends AbstractClass {
    @Override
    void brew() {
        System.out.println("泡茶！");
    }
    @Override
    void addCondiments() {
        System.out.println("添加柠檬！");
    }
    @Override
    protected boolean hook() {
        System.out.println("钩子返回喝茶不添加调料！");
        return false;
    }
}

package com.template;

public class People {
    public void drink(){
        AbstractClass c = new Coffee();
        c.templateMethod();
        System.out.println("-------------");
        AbstractClass t = new Tea();
        t.templateMethod();
    }
    public static void main(String[] args) {
        People p = new People();
        p.drink();
    }
}

计算器的例子：

package com.template;
/**
 * ClassName: AbstractCalculator 
 * @Description:模板方法模式（Template Method）：
 * 解释一下模板方法模式，就是指：一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，
 * 也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。 
 * @author Panyk
 * @date 2015年10月14日
 */
public abstract class AbstractCalculator {
    //主方法，实现对本类的其它方法的调用
    public final int calculate(String exp, String opt){
        int[] array = split(exp, opt);
        return this.calculate(array[0], array[1]);
    }
    public abstract int calculate(int num1, int num2);
    private int[] split(String exp, String opt){
        String[] arr = exp.split(opt);
        int[] arrI = new int[2];
        arrI[0] = Integer.parseInt(arr[0]);
        arrI[1] = Integer.parseInt(arr[1]);
        return arrI;
    }
}

package com.template;

public class Plus extends AbstractCalculator {
    @Override
    public int calculate(int num1, int num2) {
        return num1 + num2;
    }
}

package com.template;
public class Main {
    public static void main(String[] args) {
        AbstractCalculator ac = new Plus();
        int res = ac.calculate("3+5", "\\+");
        System.out.println("3+5="+res);
    }
}