设计模式之模板模式

1. 定义：定义了一个操作算法骨架，在这个骨架中定义了一些方法，将其中的一些方法延迟到子类中去实现，使得子类在不改变一个算法框架的同时，重新定义该算法的某些特定步骤
2. 大白话就是：抽象父类看做模板，在抽象父类中第一个模板方法，这个方法是只能被继承，不能被子类做任何的修改，在模板方法里面调用一些算法步骤（解释：这个类用来做一些事情的，做事情就要有步骤，模板方法相当于一个大纲，大纲里面有操作步骤），这些算法步骤基本上都是高度抽象出来的，有专门的作用，例如开发人员的编程操作，代码到最后都要提交到远程，就像这个提交操作，所有人都要做一样。但是这些操作有的地方可以不一样，向前端和后台的编写代码肯定不一样，这些式的方法在模板类中被定义为抽象方法，用来让子类自定义操作内容，就这样相同中带着不同
3. 举例
   后台、前台：
   产品提需求
   程序员选择编程语言
   程序员选择编程工具
   编写完成后提交代码
   审核上线
   你是优秀程序员
   这些操作是一个模板，其中可以简单的看，编程语言可以不同，编程工具可以不同，但是产品提需求，编写后提交代码，审核上线，你是优秀程序员都是模板化操作，接下来编写模板类，如下所示
   抽象基类

package com.fgy.template;

public abstract class ProgrammingTemplate {

    public final void programming() {

        //给定需求(不需要自定义操作)
        givenRequirements();
        //选择编程语言（需要）
        selectProgrammingLanguage();

        //选择编程工具（需要）
        selectProgrammingTools();

        //提交代码（不需要）
        commitCode();

        //上线审核（不需要）
        onLineAudit();

        //你是优秀的程序员（不需要）
        youAreGood();

    }

    private void youAreGood() {
        System.out.println("你是优秀的程序员");
    }

    private void onLineAudit() {
        System.out.println("领导上线进行审核");
    }

    private void commitCode() {
        System.out.println("程序员提交代码");
    }

    //抽象方法，延迟到子类中实现
    protected abstract void selectProgrammingTools();

    //抽象方法，延迟到子类中实现
    protected abstract void selectProgrammingLanguage();

    private void givenRequirements() {
        System.out.println("产品给定需求！！！！");
    }

}

两个实现子类

package com.fgy.template;

public class BackEndProgrammer extends ProgrammingTemplate {

    @Override
    protected void selectProgrammingTools() {
        System.out.println("开发用Eclipse！！！！");
    }

    @Override
    protected void selectProgrammingLanguage() {

        System.out.println("编程语言选择Java语言");
    }
}

package com.fgy.template;

public class FrontEndDeveloper extends ProgrammingTemplate {

    @Override
    protected void selectProgrammingTools() {
        System.out.println("开发工具选择IDEA!!!!!");
    }

    @Override
    protected void selectProgrammingLanguage() {
        System.out.println("编程语言选择OC！！！！");
    }

}

测试类

package com.fgy.template;

public class TextTemplate {

    public static void main(String[] args) {
        ProgrammingTemplate programmer = new BackEndProgrammer();
        programmer.programming();
        System.out.println("**********************************\n");
        ProgrammingTemplate programmer2 = new FrontEndDeveloper();
        programmer2.programming();
    }

}

测试结果

但是在开发过程中，有时候我们不想让模板中的固定不变的操作步骤出现，那我们怎么做？我们采用钩子方法，在模板中提供一个方法，让子类决定那些步骤不出现，这就是所谓的挂钩
在以上的模板类中的如下操作

 if (isSuccess()) {
    //你是优秀的程序员（不需要）
    youAreGood();            
  }

    protected boolean isSuccess() {
        return true;
    }

这个函数可以被子类继承，子类来决定 youAreGood(); 这个步骤是否可用
两个子类现在的代码如下：

package com.fgy.template;

public class BackEndProgrammer extends ProgrammingTemplate {

    @Override
    protected void selectProgrammingTools() {
        System.out.println("开发用Eclipse！！！！");
    }

    @Override
    protected void selectProgrammingLanguage() {

        System.out.println("编程语言选择Java语言");
    }

    @Override
    protected boolean isSuccess() {
        return false;
    }
}

package com.fgy.template;

public class FrontEndDeveloper extends ProgrammingTemplate {

    @Override
    protected void selectProgrammingTools() {
        System.out.println("开发工具选择IDEA!!!!!");
    }

    @Override
    protected void selectProgrammingLanguage() {
        System.out.println("编程语言选择OC！！！！");
    }

    @Override
    protected boolean isSuccess() {
        return true;
    }
}

效果如下