概念：

父类定义了一个操作中的算法骨架，将某些步骤延迟到子类中实现。或者通俗点讲，处理某个流程的代码已经都具备，当其中某个节点的代码不能确定，因此我们采用工厂模式，将这个节点的代码实现转移给子类完成；

/**
 * 模板方法模式：也称钩子函数或回调方法,
 * 定义为抽象类，让子类继承之后必须实现类中的抽象方法,
 * 当不同的类去继承的时候，可以实现不同的方法。
 * 便于新增子流程
 */
public abstract class Templatemethod {
    
    private void openSession() {
        System.out.println("开启会话");
    }
    /**
     * 【钩子方法】可以为抽象方法,子类必须实现。
     *  也可以是空的非抽象方法 protected void move() {};
     */
    protected abstract void move();
    
    //提交事务
    private void commitTransaction() {
        System.out.println("提交事务");
    }
    
    //回调函数,可以先占着这个位置，具体需要的时候，子类可以调用。
    // 在回调里面处理些问题
    public void callBack(){
        System.out.println("回调函数");
    }
    /**
     * 【模板方法】
     */
    public final void call(){
        this.openSession();
        // 【钩子方法 move()】
        this.move();
        this.commitTransaction();
        this.callBack();
    }
    
}
/**
 * 子类
 */
class Children extends Templatemethod{

    @Override
    protected void move() {
        System.out.println("访问数据库");
    }
    
}
class Test{
    public static void main(String[] args) {
        
        Templatemethod templatemethod = new Children();
        templatemethod.call();
//out:      开启回话
//out:      访问数据库
//out:      提交事务
//out:      回调函数

        //匿名内部类的方式调用
        Templatemethod templatemethod2 = new Templatemethod() {
            
            @Override
            protected void move() {
                //新增子流程：大神感觉访问数据库的方式太low，想手写数据库连接
                System.out.println("大神教你手写jdbc");
                System.out.println("访问数据库");
            }
            
            //重写回调函数 ，实现不同功能
            @Override
            public void callBack() {
                System.out.println("执行回调函数，实现不同功能");
            }

        };
        templatemethod2.call();
//out:      开启回话
//out:      大神教你手写jdbc
//out:      访问数据库
//out:      提交事务
//out:      执行回调函数，实现不同功能
    }
}