本文主要参考资料：《设计模式之禅》
本文主要目录为：
1）案例
2）模板方法改进案例
3）模板方法的定义
4）钩子函数
1. 案例
我们先看个例子：
我们现在需要做个悍马车的模型，具体类图与代码如下：
public abstract class HummerModel {
//汽车发动
public abstract void start();
//能发动，那还要能停下来
public abstract void stop();
//喇叭会出声音，是滴滴叫，还是哔哔叫
public abstract void alarm();
//引擎会轰隆隆的响，不响那是假的
public abstract void engineBoom();
//那模型应该会跑吧
public abstract void run();
}public class HummerH1Model extends HummerModel {
//H1型号的悍马车鸣笛
public void alarm() {
System.out.println("悍马H1鸣笛...");
}
//引擎轰鸣声
public void engineBoom() {
System.out.println("悍马H1引擎声音是这样在...");
}
//汽车发动
public void start() {
System.out.println("悍马H1发动...");
}
//停车
public void stop() {
System.out.println("悍马H1停车...");
}
//开动起来
public void run(){
//先发动汽车
this.start();
//引擎开始轰鸣
this.engineBoom();
//然后就开始跑了，跑的过程中遇到一条狗挡路，就按喇叭
this.alarm();
//到达目的地就停车
this.stop();
}
}public class HummerH2Model extends HummerModel {
//H2型号的悍马车鸣笛
public void alarm() {
System.out.println("悍马H2鸣笛...");
}
//引擎轰鸣声
public void engineBoom() {
System.out.println("悍马H2引擎声音是这样在...");
}
//汽车发动
public void start() {
System.out.println("悍马H2发动...");
}
//停车
public void stop() {
System.out.println("悍马H2停车...");
}
//开动起来
public void run(){
//先发动汽车
this.start();
//引擎开始轰鸣
this.engineBoom();
//然后就开始跑了，跑的过程中遇到一条狗挡路，就按喇叭
this.alarm();
//到达目的地就停车
this.stop();
}
}public class Client {
public static void main(String[] args) {
//牛叉公司要H1型号的悍马
HummerH1Model h1 = new HummerH1Model();
//H1模型演示
h1.start();
h1.engineBoom();
h1.run();
h1.alarm();
h1.run();
h1.stop();
}
}好了，我们可以看到两个实现类悍马H1和悍马H2的run（）方法都是完全相同的，那么这个run() 方法的实现应该出现在抽象类上，而不是两个实现类里面（注意：如果相同的一段代码拷贝国两次，就需要对设计产生怀疑）
2. 模板方法模式改进案例
现在我们使用模板方法进行改进，下面是类图与代码：
public abstract class HummerModel {
//发动起来
public abstract void start();
//能发动，那还要能停下来
public abstract void stop();
//喇叭会出声音，是滴滴叫，还是哔哔叫
public abstract void alarm();
//引擎会轰隆隆的响，不响那是假的
public abstract void engineBoom();
//那模型应该会跑吧
public void run(){
//先发动汽车
this.start();
//引擎开始轰鸣
this.engineBoom();
//然后就开始跑了，跑的过程中遇到一条狗挡路，就按喇叭
this.alarm();
//到达目的地就停车
this.stop();
}
}抽象悍马模型将run方法有原来的抽象方法改为了实现方法。因此下面两个实现类就不需要实现run方法了
public class HummerH1Model extends HummerModel {
//H1型号的悍马车鸣笛
public void alarm() {
System.out.println("悍马H1鸣笛...");
}
//引擎轰鸣声
public void engineBoom() {
System.out.println("悍马H1引擎声音是这样在...");
}
//汽车发动
public void start() {
System.out.println("悍马H1发动...");
}
//停车
public void stop() {
System.out.println("悍马H1停车...");
}
}public class HummerH2Model extends HummerModel {
//H2型号的悍马车鸣笛
public void alarm() {
System.out.println("悍马H2鸣笛...");
}
//引擎轰鸣声
public void engineBoom() {
System.out.println("悍马H2引擎声音是这样在...");
}
//汽车发动
public void start() {
System.out.println("悍马H2发动...");
}
//停车
public void stop() {
System.out.println("悍马H2停车...");
}
}public class Client {
public static void main(String[] args) {
//牛叉公司要H1型号的悍马
HummerModel h1 = new HummerH1Model();
//H1模型演示
h1.run();
}
}
3. 模板方式的定义
定义：Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure。定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
模板方法的类图：
模板方法模式确实非常简单，仅仅使用了Java的继承机制，但是它是一个应用非常广泛的模式。其中，AbstractClass叫做抽象模板，它的方法分为两类：
- 基本方法。基本方法也叫做基本操作，是由子类实现的方法，并且在模板方法被调用。
- 模板方法。可以有一个或几个，一般是一个具体方法，也就是一个骨架，实现对基本方法的调度，完成固定的逻辑。
在类图中还有一个角色：具体模板，ConcreteClass1和ConcreteClass2属于具体模板，实现父类所定义的一个或多个抽象方法，也就是父类定义的基本方法在子类中得以实现。
模板方法模式的优点
- 封装不变部分，扩展可变部分。把认为是不变部分的算法封装到父类实现，而可变部分的则可以通过继承来继续扩展。我们悍马模型例子中，是不是就非常容易扩展，例如增加一个H3型号的悍马模型，很容易呀，增加一个子类，实现父类的基本方法就可以了。
- 提取公共部分代码，便于维护。我们例子中刚刚走过的弯路就是最好的证明，如果我们不抽取到父类中，任由这种散乱的代码发生，想想后果是什么样子？维护人员为了修正一个缺陷，需要到处查找类似的代码！
- 行为控制交由子类来实现。基本方法是由子类实现的，因此子类可以通过扩展的方式增加相应的功能，符合开闭原则。
模板方法模式的缺点
按照我们设计习惯，抽象类负责声明最抽象、最一般的事物属性和方法，实现类完成具体的事物属性和方法，但是模板方法模式却颠倒了，抽象类定义了部分抽象方法，由子类实现，子类执行的结果影响了父类的结果，也就是子类对父类产生了影响，这在复杂的项目中，会带来代码阅读的难度，而且也会让新手产生不适感。
模板方法模式的使用场景
- 多个子类有公有的方法，并且逻辑基本相同时。
- 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现。
- 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数（见“模板方法模式的扩展”）约束其行为。
3 . 钩子函数
我们可以看到两个实例悍马H1和H2喇叭都会响，现在，我要改成悍马H1喇叭想让它响它就响，悍马H2喇叭不要响！
看下类图和代码
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 alarm() {
System.out.println("悍马H1鸣笛...");
}
@Override
protected void engineBoom() {
System.out.println("悍马H1引擎声音是这样在...");
}
@Override
protected void start() {
System.out.println("悍马H1发动...");
}
@Override
protected void stop() {
System.out.println("悍马H1停车...");
}
protected boolean isAlarm() {
return this.alarmFlag;
}
//要不要响喇叭，是有客户的来决定的
public void setAlarm(boolean isAlarm){
this.alarmFlag = isAlarm;
}
}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停车...");
}
//默认没有喇叭的——重写父类的钩子方法isAlarm（）
protected boolean isAlarm() {
return false;
}
}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型号的悍马是由客户自己去控制是否要响喇叭，也就是说外界条件改变，影响到模板方法的执行。在我们抽象类中isAlarm的返回值就是影响了模板方法的执行结果，该方法就叫钩子方法。有了钩子方法的模板方法模式才算完美。
扫一扫
3140
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
