模板方法模式的定义

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

模板方法模式的本质

固定算法骨架

模板方法模式的优缺点

缺点：算法骨架不容易升级

示例1

/**
 * 定义模板方法、原语操作等的抽象类
 */
public abstract class AbstractClass {

    /**
     * 原语操作1，所谓原语操作就是抽象的操作，必须要由子类提供实现
     */
    public abstract void doPrimitiveOperation1();

    /**
     * 原语操作2
     */
    public abstract void doPrimitiveOperation2();

    /**
     * 模板方法，定义算法骨架
     */
    public final void templateMethod() {
        doPrimitiveOperation1();
        doPrimitiveOperation2();
    }
}

/**
 * 具体实现类，实现原语操作
 */
public class ConcreteClass extends AbstractClass {


    @Override
    public void doPrimitiveOperation1() {
        //具体的实现
    }

    @Override
    public void doPrimitiveOperation2() {
        //具体的实现
    }
}

示例2

/**
 * 一个较为完整的模板定义示例
 */
public abstract class AbstractTemplate {

    /**
     * 模板方法，定义算法骨架
     */
    public final void templateMethod() {
        //第一步
        this.operation1();
        //第二步
        this.operation2();
        //第三步
        this.doPrimitiveOperation1();
        //第四步
        this.doPrimitiveOperation2();
        //第五步
        this.hookOperation1();
    }

    /**
     * 具体操作1，算法中的步骤，固定实现，而且子类不需要访问
     */
    private void operation1() {
        //在这里具体的实现
    }

    /**
     * 具体操作2，算法中的步骤，固定实现，而且子类不需要访问
     * 当然也可以定义成protected的，不可以被覆盖，因此是final的
     */
    protected final void operation2() {
        //在这里具体的实现
    }

    /**
     * 原语操作1，算法中的必要步骤，父类无法确定如何真正实现
     */
    protected abstract void doPrimitiveOperation1();

    /**
     * 原语操作2，算法中的必要步骤，父类无法确定如何真正实现
     */
    protected abstract void doPrimitiveOperation2();

    /**
     * 钩子操作，算法中的步骤，不一定需要，提供默认实现
     * 由子类选择并具体实现
     */
    protected void hookOperation1() {
        //在这里提供默认的实现
    }



    /**
     * 具体的AbstractClass操作，子类的公共功能
     * 但通常不是具体的算法步骤
     */
    protected void commonOperation() {
        //在这里具体的实现
    }

    /**
     * 工厂方法，创建某个对象，这里用Object代替了，在算法实现中可能需要
     * @return 创建的某个算法实现需要的对象
     */
    protected abstract Object createOneObject();

}