模板方法模式在一个方法中定义了一个算法的股价，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

类图



java代码



// 饮料父类
// 模板类
public abstract class Beverage {

    // 制作饮料
    // 模板方法不允许子类覆盖
    // 模板方法定义了一连串的步骤，每个步骤由一个方法代表
    public final void makeBeverage() {
        boilWater();
        brew();
        if (withCondiment()) {
            addCondiment();
        }
        pourInCup();
    }

    // 烧水
    public void boilWater() {
        System.out.println("boiling water ... ");
    }

    // 冲泡
    public abstract void brew();

    // 加入调料
    public abstract void addCondiment();

    // 导入杯子
    public void pourInCup() {
        System.out.println("pouring into cup ... ");
    }

    // 钩子（hook）方法，可以定义是否需要调料，子类可以视情况选择是否覆盖
    public boolean withCondiment() {
        return true;
    }
}

// 咖啡类
public class Coffee extends Beverage {

    private boolean flag = true;

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

    @Override
    public void addCondiment() {
        System.out.println("adding sugar and milk ... ");
    }

    @Override
    public boolean withCondiment() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

// 茶类
public class Tea extends Beverage {
    @Override
    public void brew() {
        System.out.println("steeping the tea ... ");
    }

    @Override
    public void addCondiment() {
        System.out.println("adding lemon ... ");
    }
}

// 测试类
public class Test {

    public static void main(String[] args) {
        new Test().test();
    }

    private void test() {
        // 制作咖啡
        Coffee coffee = new Coffee();
        coffee.setFlag(false);
        coffee.makeBeverage();
        // 制作茶
        Tea tea = new Tea();
        tea.makeBeverage();
    }
}



注：

由Beverage主导一切，它拥有算法，而且保护这个算法
对子类来说，Beverage类的存在，可以将代码的复用最大化
算法只存在于一个地方，所以方便修改
提供一个框架，新加入的饮料只要实现自己的方法就可以了
Beverage类专注算法本身，而有子类提供完整实现
工厂方法是模板方法的一个特殊版本
模板方法模式的变体



排序操作java代码



// 鸭子类
public class Duck implements Comparable {  // 实现Comparable接口

    private String name;
    private int weight;

    public Duck(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public int compareTo(Object o) {  // 实现compareTo方法
        Duck duck = (Duck) o;
        if (this.weight > duck.weight) {
            return 1;
        } else if (this.weight > duck.weight) {
            return 0;
        } else {
            return -1;
        }
    }
}

// 测试类
public class Test {

    public static void main(String[] args) {
        new Test().test();
    }

    private void test() {

        Duck[] ducks = {new Duck("tom", 3), new Duck("jerry", 4), new Duck("harry", 1)};
        showDucks(ducks);

        // sort相当于一个模板方法
        // compareTo相当于给子类实现的抽象方法
        Arrays.sort(ducks);
        showDucks(ducks);
    }

    private void showDucks(Duck[] ducks) {
        for (Duck duck : ducks) {
            System.out.println("name=" + duck.getName() + "; weight=" + duck.getWeight());
        }
    }
}



注：

sort方法接受一个数组，然后调用compareTo方法比较大小排序
sort方法类似于一个模板
compareTo类似于一个抽象方法
现实中总是没有那么完美的设计模式，需要作出妥协，数组不能继承

  
参考文章  
1. Head First 设计模式