1.模板方法模式概念

模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

2.模板方法模式作用

在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中实现。模板方法使得子类在不改变算法结构的情况下，重新定义算法中的某些步骤。

3.使用场景

在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异。

4.优点和缺点

优点
1、封装不变部分，扩展可变部分。
2、提取公共代码，便于维护。
3、行为由父类控制，子类实现。
缺点
每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

5.例子解析

模板方法模式类图

例子一：不使用钩子的模板方法模式

抽象方法：CaffeineBeverage

public abstract class CaffeineBeverage {

    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    public abstract void addCondiments();

    public abstract void brew();

    private void boilWater() {
        System.out.println("Boiling water");
    }
    private void pourInCup() {
        System.out.println("Pouring into cup");
    }
}

具体类一：

public class Coffee extends CaffeineBeverage {

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

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

具体类二：

public class Tea extends CaffeineBeverage {

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

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

客户端：

public class Test {

    public static void main(String[] args) {
        Tea tea = new Tea();
        tea.prepareRecipe();
        
        System.out.println("\n");
        Coffee coffee = new Coffee();
        coffee.prepareRecipe();
    }
}

例子二：使用钩子的模板方法例子

模板方法抽象类：

public abstract class CaffeineBeverageWithHook {

    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }

    public abstract void addCondiments();

    public abstract void brew();

    private void boilWater() {
        System.out.println("Boiling water");
    }
    private void pourInCup() {
        System.out.println("Pouring into cup");
    }
    //我们在这里定义一个方法，（通常）是空的缺省实现。
    //“空的缺省实现”这句话的意思是，首先“缺省”的意思是“默认”的意思，所以这句话的意思是定义一个默认不做任何事情的方法
    //这就是一个钩子，子类可以选择覆盖这个方法，也可以选择不覆盖（即默认）
    public boolean customerWantsCondiments() {
        return true;
    }
}

具体类：

public class CoffeeWithHook extends CaffeineBeverageWithHook {

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

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

    @Override
    public boolean customerWantsCondiments() {
        String answer = getUserInput();
        if (answer.toLowerCase().equals("y")) {
            return true;
        } else
            return false;
    }

    private String getUserInput() {

        String answer = null;
        System.out
                .println("Would you like sugar and milk with your caffee(y/n)?");
        BufferedReader bis = new BufferedReader(
                new InputStreamReader(System.in));
        try {
            answer = bis.readLine();
        } catch (Exception e) {
            System.err.println("IO error ,try to read your answer");
        }
        if (answer == null||answer.equals("")) {
            return "no";
        }
        return answer;
    }
}

那么，钩子到底是什么作用？
钩子可以让子类选择是否实现算法中的可选部分。

6.总结

这些例子都是《Head First Design Patterns》一书里的，它里面还有几个例子让我们更深刻的了解什么事钩子。下面总结一下了解到的知识。
1.钩子是一个方法，他在抽象类中不做事，或者只做默认的事情，子类可以选择是否重写这个钩子方法。
2.为了防止子类修改覆盖抽象类中的模板方法，可以将模板方法设置为final。
3.策略模式和模板模式都封装了算法，只是它们的实现方式不同，策略模式使用的是组合，模板模式使用的是继承。
4.工厂方法是模板方法的一个特殊版本。

7.源码下载

http://download.csdn.net/detail/lgywsdy/9750972

8.参考文章

http://www.runoob.com/design-pattern/template-pattern.html