下面橫線以上內容是借鑑別人的，為了表達對作者的敬意，不做不恰當的修改，我個人的總結在後面。

週三，9：00，我剛剛坐到位置，開啟電腦準備開始幹活。

“小三，小三，叫一下其它同事，到會議室，開會”老大跑過來吼，帶著淫笑。還不等大家坐穩，老
大就開講了,
“告訴大家一個好訊息，昨天終於把牛叉模型公司的口子打開了，要我們做悍馬模型，雖然是第一個
車輛模型，但是我們有能力，有信心做好，我們一定要…（中間省略 20 分鐘的講話，如果你聽過領導人的
講話，這個你應該能夠續上） ”
動員工作做完了，那就開始壓任務了， “這次時間是非常緊張的，只有一個星期的時間，小三，你負責
在一個星期的時間把這批 10 萬車模(注：車模是車輛模型的意思，不是香車美女那個車模)建設完成…”
“一個星期？這個…，是真做不完，要做分析，做模板，做測試，還要考慮擴充套件性、穩定性、健壯性
等，時間實在是太少了”還沒等老大說完，我就急了，再不急我的小命就折在上面了！
“那這樣，你只做實現，不考慮使用設計模式，擴充套件性等都不用考慮”老大又把我壓回去了。
“不考慮設計模式？那…”
哎，領導已經佈置任務了，那就開始死命的做吧，命苦不能怨政府，點背不能怪社會呀，然後就開始
準備動手做，在做之前先介紹一下我們公司的背景，我們公司是做模型生產的，做過橋樑模型、建築模型、
機械模型，甚至是一些政府、軍事的機密模型，這個不能說，就是把真實的實物按照一定的比例縮小或放
大，用於試驗、分析、量化或者是銷售等等，上面提到的牛叉模型公司專門銷售車輛模型的公司，自己不
生產，我們公司是第一次從牛叉模型公司接單，那我怎麼著也要把活幹好，可時間很緊張呀，怎麼辦？

既然領導都說了，不考慮擴充套件性，那好辦，我先設計個類圖：

非常簡單的實現，你要悍馬模型，我就給你悍馬模型，先寫個抽象類，然後兩個不同型號的模型實現
類，那我們把這個程式實現出來：
HummerModel 抽象類的程式清單如下：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* Hummer Model是悍馬車輛模型的意思，不是悍馬美女車模
*/
public abstract class HummerModel {
/*
* 首先，這個模型要能夠被髮動起來，別管是手搖發動，還是電力發動，反正
* 是要能夠發動起來，那這個實現要在實現類裡了
*/
public abstract void start();
//能發動，那還要能停下來，那才是真本事
public abstract void stop();
//喇叭會出聲音，是滴滴叫，還是嗶嗶叫
public abstract void alarm();
//引擎會轟隆隆的響，不響那是假的
public abstract void engineBoom();
//那模型應該會跑吧，別管是人推的，還是電力驅動，總之要會跑
public abstract void run();
}
 

H1 型號悍馬的定義如下：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* 悍馬車是每個越野者的最愛，其中H1最接近軍用系列
*/
public class HummerH1Model extends HummerModel {
@Override
public void alarm() {
System.out.println("悍馬H1鳴笛...");
}
@Override
public void engineBoom() {
System.out.println("悍馬H1引擎聲音是這樣在...");
}
@Override
public void start() {
System.out.println("悍馬H1發動...");
}
@Override
public void stop() {
System.out.println("悍馬H1停車...");
}
/*
* 這個方法是很有意思的，它要跑，那肯定要啟動，停止了等，也就是要調其他方法
*/
@Override
public void run() {
//先發動汽車
this.start();
//引擎開始轟鳴
this.engineBoom();
//然後就開始跑了，跑的過程中遇到一條狗擋路，就按喇叭
this.alarm();
//到達目的地就停車
this.stop();
}
}
 

然後看悍馬 H2 型號的實現：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* H1和H2有什麼差別，還真不知道，真沒接觸過悍馬
*/
public class HummerH2Model extends HummerModel {
@Override
public void alarm() {
System.out.println("悍馬H2鳴笛...");
}
@Override
public void engineBoom() {
System.out.println("悍馬H2引擎聲音是這樣在...");
}
@Override
public void start() {
System.out.println("悍馬H2發動...");
}
@Override
public void stop() {
System.out.println("悍馬H1停車...");
}
/*
* H2要跑，那肯定要啟動，停止了等，也就是要調其他方法
*/
@Override
public void run() {
//先發動汽車
this.start();
//引擎開始轟鳴
this.engineBoom();
//然後就開始跑了，跑的過程中遇到一條狗擋路，就按喇叭
this.alarm();
//到達目的地就停車
this.stop();
}
}

然後程式寫到這裡，你就看到問題了，run 方法的實現應該在抽象類上，不應該在實現類上，好，我們
修改一下類圖和實現：

就把 run 方法放到了抽象類中，那程式碼也相應的改變一下，先看 HummerModel.java:

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* Hummer Model是悍馬車輛模型的意思，不是悍馬美女車模
*/
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();
}
}

下面是 HummerH1Model.java 程式清單：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* 悍馬車是每個越野者的最愛，其中H1最接近軍用系列
*/
public class HummerH1Model extends HummerModel {
@Override
public void alarm() {
System.out.println("悍馬H1鳴笛...");
}
@Override
public void engineBoom() {
System.out.println("悍馬H1引擎聲音是這樣在...");
}
@Override
public void start() {
System.out.println("悍馬H1發動...");
}
@Override
public void stop() {
System.out.println("悍馬H1停車...");
}
}

下面是 HummerH2Model.java 的程式清單：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* H1和H2有什麼差別，還真不知道，真沒接觸過悍馬
*/
public class HummerH2Model extends HummerModel {
@Override
public void alarm() {
System.out.println("悍馬H2鳴笛...");
}
@Override
public void engineBoom() {
System.out.println("悍馬H2引擎聲音是這樣在...");
}
@Override
public void start() {
System.out.println("悍馬H2發動...");
}
@Override
public void stop() {
System.out.println("悍馬H2停車...");
}
}

類圖修改完畢了，程式也該好了，提交給老大，老大一看，挺好，就開始生產了，並提交給客戶使用
了，那客戶是如何使用的呢？類圖上增加一個 Client 類，就是客戶，我們這個是用 main 函式來代替他使
用，類圖如下：

然後看增加的 Client.java 程式，非常的簡單：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* 客戶開始使用這個模型
*/
public class Client {
public static void main(String[] args) {
//客戶開著H1型號，出去遛彎了
HummerModel h1 = new HummerH1Model();
h1.run(); //汽車跑起來了；
//客戶開H2型號，出去玩耍了
HummerModel h2 = new HummerH2Model();
h2.run();
}
}

執行的結果如下：
              悍馬H1發動...
              悍馬H1引擎聲音是這樣在...
              悍馬H1鳴笛...
              悍馬H1停車...
              悍馬H2發動...
              悍馬H2引擎聲音是這樣在...
              悍馬H2鳴笛...
              悍馬H2停車...
非常非常的簡單，那如果我告訴這就是模板方法模式你會不會很不屑呢？就這模式，太簡單了，我一
直在使用呀，是的，你經常在使用，但你不知道這是模板方法模式，那些所謂的高手就可以很牛 X 的說“用
模板方法模式就可以實現…” ，你還要很崇拜的看著，哇，牛人，模板方法模式是什麼呀?
然後我們繼續回顧我們這個模型，回頭一想，不對呀，需求分析的有點問題，客戶要關心模型的啟動，
停止，鳴笛，引擎聲音嗎？他只要在 run 的過程中，聽到或看都成了呀，暴露那麼多的方法幹啥？好了，
我們重新修改一下類圖：

好了，這才是模板方法模式，就是這個樣子，我們只要修改抽象類程式碼就可以了，HummerModel.java
程式清單如下：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* Hummer Model是悍馬車輛模型的意思，不是悍馬美女車模
*/
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();
//然後就開始跑了，跑的過程中遇到一條狗擋路，就按喇叭
this.alarm();
//到達目的地就停車
this.stop();
}
}

其他的子類都不用修改(如果要修改，就是把四個方法的訪問許可權由 public 修改 protected)，大家請
看這個 run 方法， 他定義了呼叫其他方法的順序， 並且子類是不能修改的， 這個叫做模板方法； start、 stop、
alarm、engineBoom 這四個方法是子類必須實現的，而且這四個方法的修改對應了不同的類，這個叫做基本
方法，基本方法又分為三種：在抽象類中實現了的基本方法叫做具體方法；在抽象類中沒有實現，在子類
中實現了叫做抽象方法，我們這四個基本方法都是抽象方法，由子類來實現的；還有一種叫做鉤子方法，
這個等會講。
到目前為止，這兩個模型都穩定的執行，突然有一天，老大又找到了我，
“客戶提出新要求了，那個喇叭想讓它響就響，你看你設計的模型，車子一啟動，喇叭就狂響，趕快
修改一下” ，確實是設計缺陷，呵呵，不過是我故意的，那我們怎麼修改呢？看修改後的類圖：

增加一個方法，isAlarm()，喇嘛要不要響，這就是鉤子方法(Hook Method)，那我們只要修改一下抽
象類就可以了：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* Hummer Model是悍馬車輛模型的意思，不是悍馬美女車模
*/
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;
}
}

鉤子方法模式是由抽象類來實現的，子類可以重寫的，H2 型號的悍馬是不會叫的，喇叭是個擺設，看
HummerH2Model.java 程式碼：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* H1和H2有什麼差別，還真不知道，真沒接觸過悍馬
*/
public class HummerH2Model extends HummerModel {
@Override
protected void alarm() {
System.out.println("悍馬H2鳴笛...");
}
@Override
protected void engineBoom() {
System.out.println("悍馬H2引擎聲音是這樣在...");
}
@Override
protected void start() {
System.out.println("悍馬H2發動...");
}
@Override
protected void stop() {
System.out.println("悍馬H1停車...");
}
//預設沒有喇叭的
@Override
protected boolean isAlarm() { 
return false;
}
}

那 H2 型號的模型都沒有喇叭，就是按了喇叭也沒有聲音，那客戶端這邊的呼叫沒有任何修改，出來的
結果就不同，我們先看 Client.java 程式：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* 客戶開始使用這個模型
*/
public class Client {
public static void main(String[] args) {
HummerH2Model h2 = new HummerH2Model();
h2.run(); //H2型號的悍馬跑起來
}
}

執行的出來的結果是這樣的：

                  悍馬H2發動...
                  悍馬H2引擎聲音是這樣在...
                  悍馬H1停車...

那 H1 又有所不同了，它的喇叭要不要響是由客戶來決定，其實在類圖上已經標明瞭 setAlarm 這個方
法，我們看 HummerH1Model.java 的程式碼：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* 悍馬車是每個越野者的最愛，其中H1最接近軍用系列
*/
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停車...");
}
@Override
protected boolean isAlarm() {
return this.alarmFlag;
}
//要不要響喇叭，是有客戶的來決定的
public void setAlarm(boolean isAlarm){
this.alarmFlag = isAlarm;
}
}

這段程式碼呢修改了兩個地方，一是重寫了父類的 isAlarm()方法，一是增加了一個 setAlarm 方法，由
呼叫者去決定是否要這個功能，也就是喇叭要不要滴滴答答的響，哈哈，那我們看看 Client.java 的修改：

package com.cbf4life;
/**
* @author cbf4Life [email protected]
* I'm glad to share my knowledge with you all.
* 客戶開始使用這個模型
*/
public class Client {
public static void main(String[] args) {
//客戶開著H1型號，出去遛彎了
HummerH1Model h1 = new HummerH1Model();
h1.setAlarm(true);
h1.run(); //汽車跑起來了；
}
}

執行的結果如下：
             悍馬H1發動...
             悍馬H1引擎聲音是這樣在...
             悍馬H1鳴笛...
             悍馬 H1 停車...

看到沒，這個模型 run 起來就有聲音了，那當然把 h1.setAlarm(false)執行起來喇叭就沒有聲音了，
鉤子方法的作用就是這樣滴。
那我們總結一下模板方法模式，模板方法模式就是在模板方法中按照一個的規則和順序呼叫基本方法，
具體到我們上面那個例子就是 run 方法按照規定的順序(先呼叫 start,然後再呼叫 engineBoom，再呼叫
alarm，最後呼叫 stop)呼叫本類的其他方法，並且由 isAlarm 方法的返回值確定 run 中的執行順序變更，
通用類圖如下：

其中 TemplateMethod 就是模板方法，operation1 和 operation2 就是基本方法，模板方法是通過彙總
或排序基本方法而產生的結果集。模板方法在一些開源框架中應用很多，它提供了一個抽象類，然後開源
框架寫了一堆子類，在《XXX In Action》中就說明了，如果你需要擴充套件功能，可以繼承了這個抽象類，然
後修改 protected 方法，再然後就是呼叫一個類似 execute 方法，就完成你的擴充套件開發，確實是一種簡單
的模式。

定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中。TemplateMethod使得子類可以不改變一個演算法的結構即

可重定義該演算法的某些特定步驟。

適用性：

一次性實現一個演算法的不變的部分，並將可變的行為留給子類來實現。

各子類中公共的行為應被提取出來並集中到一個公共父類中以避免程式碼重複。這是Opdyke和Johnson所描述過的“重

分解以一般化”的一個很好的例子[ OJ93 ]。首先識別現有程式碼中的不同之處，並且將不同之處分離為新的操作。最

後，用一個呼叫這些新的操作的模板方法來替換這些不同的程式碼。

控制子類擴充套件。模板方法只在特定點呼叫“hook ”操作（參見效果一節），這樣就只允許在這些點進行擴充套件。