headfirst設計模式（9）—模板方法模式
前言
這一章的模板方法模式，個人感覺它是一個簡單，並且實用的設計模式，先說說它的定義：
模板方法模式定義了一個演算法的步驟，並允許子類別為一個或多個步驟提供其實踐方式。讓子類別在不改變演算法架構的情況下，重新定義演算法中的某些步驟。（百度百科）
額， 這段定義呢，如果說我在不瞭解這個設計模式的時候，我看著反正是雲裡霧裡的，畢竟定義嘛，就是用一堆看不懂的名詞把一個看不懂的名詞描述出來，但是學了這個設計模式，反過來看，又會覺得它的定義很正確。
模板方法模式的關鍵點有3個：
1，有一個由多個步驟構成的方法（模板方法）
2，子類可以自行實現其中的一個或多個步驟（模板方法中的步驟）
3，架構允許的情況下，子類可以重新定義某些步驟
話說，這不就是上面那段話嗎？列成3點以後咋感覺越看越玄了呢？難道這就是傳說中的玄學程式設計？
列出來的目的是，後面的例子裡面會依次講到這3點，話不多說，程式碼在idea裡面已經蓄勢待發！
模板方法模式基本實現
1，故事背景
在實現之前呢，需要有一個歷史背景，不然不知道來龍去脈，容易印象不深刻，headfirst裡面是這樣的一個例子：
在一個店裡面，有2種飲料，它們的沖泡步驟是這樣的：
1，咖啡：把水煮沸，用沸水沖泡咖啡，倒進杯子，加糖和牛奶
2，茶：把水煮沸，用沸水浸泡茶葉，倒進杯子，加檸檬
當然，本著沒有專業的自動化釀造技術的咖啡店不是一個好的科技公司，這段邏輯當然得用程式碼來實現了啊，然後就進入大家最喜歡的貼程式碼環節：
/**
* 咖啡
*/
public class Coffee {
/**
* 準備
*/
public void prepare() {
boilWater();//把水煮沸
brewCoffeeGrinds();//沖泡咖啡
pourInCup();//倒進杯子
addSugarAndMilk();//新增糖和牛奶
}
/**
* 把水煮沸
*/
private void boilWater() {
System.out.println("把水煮沸");
}
/**
* 沖泡咖啡
*/
private void brewCoffeeGrinds() {
System.out.println("用沸水沖泡咖啡");
}
/**
* 倒進杯子
*/
private void pourInCup() {
System.out.println("倒進杯子");
}
/**
* 新增糖和牛奶
*/
private void addSugarAndMilk() {
System.out.println("新增糖和牛奶");
}
}
/**
* 茶
*/
public class Tea {
/**
* 準備
*/
public void prepare() {
boilWater();//把水煮沸
steepTeaBag();//泡茶
pourInCup();//倒進杯子
addLemon();//加檸檬
}
/**
* 把水煮沸
*/
private void boilWater() {
System.out.println("把水煮沸");
}
/**
* 泡茶
*/
private void steepTeaBag() {
System.out.println("用沸水浸泡茶葉");
}
/**
* 倒進杯子
*/
private void pourInCup() {
System.out.println("倒進杯子");
}
/**
* 加檸檬
*/
private void addLemon() {
System.out.println("新增檸檬");
}
}
上面貼了咖啡和茶的實現，對外提供的public方法是prepare()方法，其他的內部方法，都是private（不需要的方法不要提供出去，外面的世界鍋太多，它們還小，經不住那麼多的打擊），按道理來說，上面兩段程式碼，思路清晰，註釋完整，程式碼整潔。
但是，boilWater()，pourInCup()兩個方法，其實內容是一模一樣的，對於一個程式來說，有2段一模一樣的程式碼的時候，就應該思考，是不是有什麼地方不對。因為，有2段就表示要改2個同樣的地方，有10段，就要改10個同樣的地方，System.out.println()當然能改啊。
邏輯一多咋辦？邏輯一多當然也能改啊，畢竟總所周知，程式設計師是隻需要3個鍵(Ctrl，C，V)就能正常工作的。但是，還有鍵盤在別人手上啊，他們寫在什麼地方的知道不？
2，邏輯抽象第一版
邏輯上來說，這個地方就會被抽象出一個公共類：
/**
* 咖啡因的飲料(將燒水和倒進杯子兩個方法抽象出來)
*/
public abstract class CaffeineBeverage {
public abstract void prepare();//子類必須要有一個準備飲料的方法
/**
* 把水煮沸
*/
protected void boilWater() {
System.out.println("把水煮沸");
}
/**
* 倒進杯子
*/
protected void pourInCup() {
System.out.println("倒進杯子");
}
}
咖啡和茶的實現就會變成下面這樣：
/**
* 咖啡
*/
public class Coffee extends CaffeineBeverage{
/**
* 準備
*/
public void prepare() {
boilWater();//把水煮沸
brewCoffeeGrinds();//沖泡咖啡
pourInCup();//倒進杯子
addSugarAndMilk();//新增糖和牛奶
}
/**
* 沖泡咖啡
*/
private void brewCoffeeGrinds() {
System.out.println("用沸水沖泡咖啡");
}
/**
* 新增糖和牛奶
*/
private void addSugarAndMilk() {
System.out.println("新增糖和牛奶");
}
}
/**
* 茶
*/
public class Tea extends CaffeineBeverage{
/**
* 準備
*/
public void prepare() {
boilWater();//把水煮沸
steepTeaBag();//泡茶
pourInCup();//倒進杯子
addLemon();//加檸檬
}
/**
* 泡茶
*/
private void steepTeaBag() {
System.out.println("用沸水浸泡茶葉");
}
/**
* 加檸檬
*/
private void addLemon() {
System.out.println("新增檸檬");
}
}
一般來說，實際業務中，抽象到這個地方，已經比複製貼上的時候好很多了。但是，很多時候，不能只看表面，還需要總結更加深層次的東西，讓業務的實現變得更加簡單。
比如在這個例子中，prepare()方法中的步驟還可以總結，抽象。
原來的沖泡步驟：
1，咖啡：把水煮沸，用沸水沖泡咖啡，倒進杯子，加糖和牛奶
2，茶：把水煮沸，用沸水浸泡茶葉，倒進杯子，加檸檬
抽象後：
咖啡/茶：把水煮沸，用沸水 【沖泡咖啡/浸泡茶葉】，倒進杯子，加 【糖和牛奶/檸檬】
第2步和第4步，還可以抽象成，沖泡，加調味品
3，模板方法模式抽象
那麼抽象類的程式碼就會變成這樣：
/**
* 咖啡因的飲料(模板方法模式)
*/
public abstract class CaffeineBeverage {
/**
* 準備（構造成final方法，防止子類重寫演算法）
*/
final void prepare() {
boilWater();
brew();
pourInCup();
addCondiments();
}
/**
* 沖泡
*/
abstract void brew();
/**
* 新增調料
*/
abstract void addCondiments();
/**
* 把水煮沸
*/
public void boilWater() {
System.out.println("把水煮沸");
}
/**
* 倒進杯子
*/
public void pourInCup() {
System.out.println("倒進杯子");
}
}
咖啡和茶的實現如下：
/**
* 咖啡
*/
public class Coffee extends CaffeineBeverage {
/**
* 沖泡咖啡
*/
void brew() {
System.out.println("用沸水沖泡咖啡");
}
/**
* 新增糖和牛奶
*/
void addCondiments() {
System.out.println("新增糖和牛奶");
}
}
/**
* 茶
*/
public class Tea extends CaffeineBeverage {
/**
* 泡茶
*/
void brew() {
System.out.println("用沸水浸泡茶葉");
}
/**
* 加檸檬
*/
void addCondiments() {
System.out.println("新增檸檬");
}
}
測試類：
/**
* 測試類
*/
public class Test {
public static void main(String[] args) {
Tea tea = new Tea();
Coffee coffee = new Coffee();
System.out.println("泡茶...");
tea.prepare();
System.out.println("衝咖啡...");
coffee.prepare();
}
}
測試結果：
泡茶... 把水煮沸 用沸水浸泡茶葉 倒進杯子 新增檸檬 衝咖啡... 把水煮沸 用沸水沖泡咖啡 倒進杯子 新增糖和牛奶
這個就是一個模板方法模式比較通用的一個實現了，中間就有模板方法模式的2個要點：
（1），有一個由多個步驟構成的方法，這裡就是prepare()，由4個步驟構成的一個模板方法
（2），子類可以自行實現其中的一個或多個步驟，咖啡和茶分別都實現了brew()，addCondiments()
其實到這個地方呢，模板方法模式的一般邏輯就大概講完了，一般來說，實現也就是上面的那個樣子，但是，還是有很多時候，會出現各種各樣的其他實現方式，畢竟抽象這個東西，對於不同的業務，不同的邏輯，那簡直就是多種多樣，只要不違背設計原則，簡單易用，那麼總會有意識無意識的用到模板方法模式。
接下來就介紹幾種常見的操作。
模板方法模式的常見操作
1，空實現
比如說，在把水煮沸前有一個前置步驟，有的飲料需要，但是有的飲料不需要，那麼就可以在模板方法裡面，給它留一個位置，讓子類去選擇性的覆蓋實現
/**
* 咖啡因的飲料(模板方法模式，空實現)
*/
public abstract class CaffeineBeverage {
/**
* 準備（構造成final方法，防止子類重寫演算法）
*/
final void prepare() {
beforeBoilWater();
boilWater();
brew();
pourInCup();
addCondiments();
}
/**
* 燒水前置操作
*/
protected void beforeBoilWater(){
}
//其他方法省略...
}
2，預設實現
比如說，加調味品這個步驟其實是可選的，加不加調味品，每種飲料加不加調味品，模板方法可以交給子類自己去控制。
/**
* 咖啡因的飲料(模板方法模式，預設實現)
*/
public abstract class CaffeineBeverage {
/**
* 準備（構造成final方法，防止子類重寫演算法）
*/
final void prepare() {
boilWater();
brew();
pourInCup();
if(needCondiments()){
addCondiments();
}
}
/**
* 是否需要調味品
*/
protected boolean needCondiments(){
return false;
}
//其他方法省略...
}
這既是模板方法模式的第3個要點， 架構允許 的情況下，子類可以重新定義某些步驟，只要模板方法可以定義新增或者移除某個，某些步驟，那麼子類就可以根據自己的實際情況來選擇實現整個方法的邏輯步驟。這個也就是這個設計模式中常說的一種叫鉤子方法。
總結
模板方法模式，其實就是，在抽象類中定義一個操作中的演算法的步驟，而將一些步驟的實現延遲到子類中。
這裡有一個建議是，儘量在抽象的時候，保證僅存在父類的方法去呼叫子類的方法，而不要同時存在子類的方法去呼叫父類的方法。
個人覺得，這樣做的原因有幾點：
1，貫徹這個建議後，整個邏輯會顯得很簡單易懂，反正沒有實現的，在子類就能找到實現
2，相互依賴調來調去的後果就是在系統越來越複雜以後，最後就沒人能看懂了
3，防止抽象類的方法變動引起子類的改動，這個其實不算原因，因為一般來說，抽象類是比較穩定的，而且，子類可以調的抽象類方法在修改時肯定要考量子類的，不允許子類呼叫的方法肯定都處理過了，一般肯定是調不到的（誒，反射你湊過來幹嘛？）
最後的最後，總結一下模板方法模式的優缺點吧
優點：
1，程式碼複用便於維護，子類可擴充套件
2，行為由父類控制，子類只需要關心自己所需要的步驟即可，開發難度低
缺點：
1，每一個不同的實現都需要一個子類來實現，導致類的個數增加，使得系統更加龐大
所以，如果發現子類很多，是不是要想想是不是設計模式用錯了，去隔壁找找其他的設計模式吧