现实生活中经常存在这样的场景，某件事情的基本流程已定，但每步或其中几步流程具体如何实施却可自由发挥，这种场景映射到设计模式中就是模板方法，或者Template method

使用场景

当某个流程或算法的大致流程已定，但其中的某些步骤的实现需（或最好）推迟至其子类进行实现；此时即考虑使用模板方法模式；同时在前述场景下又可进行进一步细分：

• 流程中大概的步骤已经固定，具体流程实现者只是定制特定步骤的实现，而不改变整体的流程
• 流程中大概的步骤已经固定，具体流程实现者不但可以定制特定步骤的实现，还能控制流程中某些步骤选择性执行

对于第二种细分场景，我们可以通过一种称之为钩子（hook）的方法进行流程控制

代码示例

首先假设有一个基本流程的定义类TemplateInterface，在基本流程方法templateMethod()中定义了执行的基本步骤，在步骤方法中，step1()与step3()已有默认的实现，而step2()与step4()是抽象方法，需在子类中实现，并且step4()不属于必须执行的步骤，所以就提供了一个钩子方法shouldDoStep4()以供子类控制step4()执行与否

public abstract class TemplateInterface {
       private void step1() {
            System. out.println("TemplateInterface step1" );
      }
       public abstract void step2();
      
       private void step3() {
            System. out.println("TemplateInterface step3" );
      }
      
       public abstract void step4();
      
       public boolean shouldDoStep4() {//钩子方法
             return true ;
      }
      
       public final void templateMethod() {
             //template begin
            step1();
            step2();
            step3();
             if(shouldDoStep4()){//钩子
                  step4();
            }
             //template ends
      }
}

再来看模板的第一个子类，暂且称之为子模板1，它重写了步骤方法step2()与step4()以及钩子方法shouldDoStep4()，可以发现在子模板1中，step4()是需要执行的

public class TemplateImplements_1 extends TemplateInterface{

       @Override
       public void step2() {
            System. out.println("TemplateImplements_1 step2" );
      }

       @Override
       public void step4() {
            System. out.println("TemplateImplements_1 step4" );
      }

      
       public boolean shouldDoStep4() {
             return true ;
      }
}

然后来看模板的另外一个子类，暂且称之为子模板2，它也重写了步骤方法step2()与step4()以及钩子方法shouldDoStep4()，不同的是，在模板2的使用场景下，step4()是不需要执行的

public class TemplateImplements_2 extends TemplateInterface{
       @Override
       public void step2() {
            System. out.println("TemplateImplements_2 step2" );
      }

       @Override
       public void step4() {
            System. out.println("TemplateImplements_2 step4" );
      }
      
       public boolean shouldDoStep4() {
             return false ;
      }
}

最后来看调用结果

public class TemplateTest {
       public static void main(String[] args) {
            TemplateInterface templateImplements_1 = new TemplateImplements_1();
          System.out.println("template 1 begin");
          templateImplements_1.templateMethod();
          System.out.println("template 1 end");
          TemplateInterface templateImplements_2 = new TemplateImplements_2();
          System.out.println();
          System.out.println("template 2 begin");
          templateImplements_2.templateMethod();
          System.out.println("template 2 end");
      }
}

//运行结果
template 1 begin
TemplateInterface step1
TemplateImplements_1 step2
TemplateInterface step3
TemplateImplements_1 step4
template 1 end

template 2 begin
TemplateInterface step1
TemplateImplements_2 step2
TemplateInterface step3
template 2 end

可以发现，模板1与模板2分别就特定步骤完成了自己的实现，并且通过钩子方法，模板2可控制自己的执行流程里没有step4()

基于模板方法模式，父类控制流程以及公共行为，子类负责具体实现，实现代码复用，同时子类还可通过hook实现反向控制，模板方法模式很好的体现了开闭原则（OCP）