模板方法模式

/*
 * 抽象模板类
 */
public abstract class AbstractSoftProject {

    //基本方法
    protected abstract void analysis();
    protected abstract void design();
    protected abstract void develop();
    protected abstract void testing();
    protected abstract void publish();

    //模板方法
    public final void execute(){
        this.analysis();
        this.design();
        this.develop();
        this.testing();
        if(this.isPublish()){
            this.publish();
        }
    }
    //钩子方法
    protected boolean isPublish(){
        return true;
    }
}

/*
 *具体模板类（A项目）
 */
public class ProjectA extends AbstractSoftProject{

    private boolean publishFlag = false;

    @Override
    protected void analysis() {
        System.out.println("需求分析");
    }
    @Override
    protected void design() {
        System.out.println("项目设计");
    }
    @Override
    protected void develop() {
        System.out.println("实施开发");
    }
    @Override
    protected void testing() {
        System.out.println("项目测试");
    }
    @Override
    protected void publish() {
        System.out.println("项目发布");
    }

    protected boolean isPublish(){
        return this.publishFlag;
    }
    public void setPublish(boolean isPublish){
        this.publishFlag = isPublish;
    }
}

/*
 * 场景类
 */
public class Scene {

    public static void main(String[] args) {

        ProjectA projectA = new ProjectA();
        projectA.setPublish(false);
        projectA.execute();
    }
}

优点

• 封装不变部分，扩展可变部分
• 提取公共部分代码，便于维护
• 行为由父类控制，子类实现

缺点

• 按照我们的设计习惯，抽象类负责声明最抽象、最一般的事物属性和方法，实现类完成具体的事物属性和方法。但是模板方法模式却颠倒了，抽象类定义了部分抽象方法，由子类实现，子类执行的结果影响了父类的结果，也就是子类对父类产生了影响，这在复杂的项目中，会带来代码阅读的难度

使用场景

• 多个子类公有的方法，且逻辑基本相同
• 重要、复杂的算法，可以把核心算法设计成模板方法，相应的细节功能由子类完成
• 重构时，可以将相同的代码提取到父类中，然后通过钩子函数约束其行为