设计模式之禅-模板方法模式

模板方法模式

定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
模板方法模式确实非常简单，仅仅使用了Java的继承机制，但它是一个应用非常广泛的模式。其中，AbstractClass叫做抽象模板，它的方法分为两类：

• 基本方法。基本方法也叫做基本操作，是由子类实现的方法，并且在模板方法被调用。
• 模板方法。可以有一个或几个，一般是一个具体方法，也就是一个框架，实现对基本方法的调度， 完成固定的逻辑。

注意：为了防止恶意的操作，一般模板方法都加上final关键字，不允许被覆写。

在类图中还有一个角色：具体模板。ConcreteClass1和ConcreteClass2属于具体模板，实 现父类所定义的一个或多个抽象方法，也就是父类定义的基本方法在子类中得以实现。

public abstract class AbstractClass {
    /**
     * 基本方法
     */
    protected abstract void doSomething();

    /**
     * 基本方法
     */
    protected abstract void doAnything();

    /**
     * 模板方法
     */
    public void templateMethod() {
        this.doSomething();
        this.doAnything();
    }
}

public class ConcreteClass1 extends AbstractClass {
    @Override
    protected void doSomething() {
        // 业务逻辑
    }

    @Override
    protected void doAnything() {
        // 业务逻辑
    }
}

public class ConcreteClass2 extends AbstractClass {
    @Override
    protected void doSomething() {
        // 业务逻辑
    }

    @Override
    protected void doAnything() {
        // 业务逻辑
    }
}

public class Client {
    public static void main(String[] args) {
        ConcreteClass1 class1 = new ConcreteClass1();
        ConcreteClass2 class2 = new ConcreteClass2();
        class1.templateMethod();
        class2.templateMethod();
    }
}

优点

• 封装不变部分，扩展可变部分。把认为是不变部分的算法封装到父类实现，而可变部分的则可以通过继承来继续扩展。
• 提取公共部分代码，便于维护
• 行为由父类控制，子类实现基本方法是由子类实现的，因此子类可以通过扩展的方式增加相应的功能，符合开闭原则。

缺点

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

使用场景

• 多个子类有公有的方法，并且逻辑基本相同时。
• 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现。
• 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数约束其行为。

扩展

public abstract class HummerModel {
    protected abstract void start();
    protected abstract void stop();
    protected abstract void alarm();
    protected abstract void engineBoom();
    final public void run(){
        this.start();
        this.engineBoom();
        if (this.isAlarm()){
            this.alarm();
        }
        this.stop();
    }
    protected boolean isAlarm(){
        return true;
    }
}

public class HummerH1Model extends HummerModel {
    private boolean alarmFlag = true;
    @Override
    protected void start() {
        System.out.println("H1发动");
    }

    @Override
    protected void stop() {
        System.out.println("H1停车");
    }

    @Override
    protected void alarm() {
        System.out.println("H1鸣笛");
    }

    @Override
    protected void engineBoom() {
        System.out.println("H1引擎");
    }
    @Override
    protected boolean isAlarm(){
        return this.alarmFlag;
    }
    public void setAlarm(boolean isAlarm){
        this.alarmFlag = isAlarm;
    }
}

public class HummerH2Model extends HummerModel {
    private boolean alarmFlag = true;
    @Override
    protected void start() {
        System.out.println("H2发动");
    }

    @Override
    protected void stop() {
        System.out.println("H2停车");
    }

    @Override
    protected void alarm() {
        System.out.println("H2鸣笛");
    }

    @Override
    protected void engineBoom() {
        System.out.println("H2引擎");
    }
    @Override
    protected boolean isAlarm(){
        return this.alarmFlag;
    }
    public void setAlarm(){
        this.alarmFlag = false;
    }
}

public class Client {
    private static final String DONT_NEED_ALARM = "0";
    private static final String NEED_ALARM = "1";
    public static void main(String[] args) throws IOException {
        System.out.println("---------------H1----------------");
        System.out.println("H1需要喇叭吗？ 0-不需要 1-需要");
        String type = (new BufferedReader(new InputStreamReader(System.in))).readLine();
        HummerH1Model h1 = new HummerH1Model();
        if (DONT_NEED_ALARM.equals(type)){
            h1.setAlarm(false);
        }
        h1.run();
        System.out.println("---------------H2----------------");
        HummerH2Model h2 = new HummerH2Model();
        h2.run();
    }
}

在我们的抽象类中isAlarm的返回值就是影响了模板方法的执行结果，该方法就叫做钩子方法（Hook Method）。