10.4 模板方法模式的扩展

发表于 更新于 分类于 ， ， Waline： 本文字数： 3.5k 阅读时长 ≈ 3 分钟

10.4 模板方法模式的扩展

到目前为止，这两个模型都稳定地运行，突然有一天，老大急匆匆地找到了我：

“看你怎么设计的，车子一启动，喇叭就狂响，吵死人了！客户提出H1型号的悍马喇叭想让它响就响，H2型号的喇叭不要有声音，赶快修改一下。”

自己惹的祸，就要想办法解决它，稍稍思考一下，解决办法有了，先画出类图，如图10-4所示。

image-20210928152314427

图10-4 扩展悍马车模类图

类图改动似乎很小，在抽象类HummerModel中增加了一个实现方法isAlarm，确定各个型号的悍马是否需要声音，由各个实现类覆写该方法，同时其他的基本方法由于不需要对外提供访问，因此也设计为protected类型。其源代码如代码清单10-9所示。

代码清单10-9 扩展后的抽象模板类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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;
    }
}

在抽象类中，isAlarm是一个实现方法。其作用是模板方法根据其返回值决定是否要响喇叭，子类可以覆写该返回值，由于H1型号的喇叭是想让它响就响，不想让它响就不响， 由人控制，其源代码如代码清单10-10所示。

代码清单10-10 扩展后的H1悍马

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class HummerH1Model extends HummerModel {
    private boolean alarmFlag = true;
    //要响喇叭
    protected void alarm() {
        System.out.println("悍马H1鸣笛...");
    }
    protected void engineBoom() {
        System.out.println("悍马H1引擎声音是这样的...");
    }
    protected void start() {
        System.out.println("悍马H1发动...");
    }
    
    protected void stop() {
        System.out.println("悍马H1停车...");
    }
    protected boolean isAlarm() {
        return this.alarmFlag;
    }
    //要不要响喇叭，是由客户来决定的
    public void setAlarm(boolean isAlarm){
        this.alarmFlag = isAlarm;
    }
}

只要调用H1型号的悍马，默认是有喇叭响的，当然你可以不让喇叭响，通过isAlarm(false)就可以实现。H2型号的悍马是没有喇叭声响的，其源代码如代码清单10-11所示。

代码清单10-11 扩展后的H2悍马

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class HummerH2Model extends HummerModel {
    protected void alarm() {
        System.out.println("悍马H2鸣笛...");
    }
    protected void engineBoom() {
        System.out.println("悍马H2引擎声音是这样的...");
    }
    protected void start() {
        System.out.println("悍马H2发动...");
    }
    protected void stop() {
        System.out.println("悍马H2停车...");
    }
    //默认没有喇叭的
    protected boolean isAlarm() {
        return false;
    }
}

H2型号的悍马设置isAlarm()的返回值为false，也就是关闭了喇叭功能。场景类代码如代码清单10-12所示。

代码清单10-12 扩展后的场景类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Client {
    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(type.equals("0")){
            h1.setAlarm(false);
        }
        h1.run();
        System.out.println("\n-------H2型号悍马--------");
        HummerH2Model h2 = new HummerH2Model();
        h2.run();
    }
}

运行是需要交互的，首先，要求输入H1型号的悍马是否有声音，如下所示：

1
2
-------H1型号悍马-------- 
H1型号的悍马是否需要喇叭声响？0-不需要 1-需要

输入“0”后的运行结果如下所示：

1
2
3
4
5
6
7
8
9
10
-------H1型号悍马-------- 
H1型号的悍马是否需要喇叭声响？0-不需要 1-需要 
0
悍马H1发动... 
悍马H1引擎声音是这样的... 
悍马H1停车... 
-------H2型号悍马-------- 
悍马H2发动... 
悍马H2引擎声音是这样的... 
悍马H2停车...

输入“1”后的运行结果如下所示：

1
2
3
4
5
6
7
8
9
10
11
-------H1型号悍马-------- 
H1型号的悍马是否需要喇叭声响？0-不需要 1-需要 
1
悍马H1发动... 
悍马H1引擎声音是这样的...
悍马H1鸣笛... 
悍马H1停车... 
-------H2型号悍马-------- 
悍马H2发动... 
悍马H2引擎声音是这样的... 
悍马H2停车...

看到没，H1型号的悍马是由客户自己控制是否要响喇叭，也就是说外界条件改变，影响到模板方法的执行。在我们的抽象类中isAlarm的返回值就是影响了模板方法的执行结果，该方法就叫做钩子方法（Hook Method）。有了钩子方法模板方法模式才算完美，大家可以想想，由子类的一个方法返回值决定公共部分的执行结果，是不是很有吸引力呀！

模板方法模式就是在模板方法中按照一定的规则和顺序调用基本方法，具体到前面那个例子，就是run()方法按照规定的顺序（先调用start()，然后再调用engineBoom()，再调用alarm()，最后调用stop()）调用本类的其他方法，并且由isAlarm()方法的返回值确定run()中的执行顺序变更。