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()当然能改啊。
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;
}
//其他方法省略...
}
总结
模板方法模式，其实就是，在抽象类中定义一个操作中的算法的步骤，而将一些步骤的实现延迟到子类中。
这里有一个建议是，尽量在抽象的时候，保证仅存在父类的方法去调用子类的方法，而不要同时存在子类的方法去调用父类的方法。
个人觉得，这样做的原因有几点：
1，贯彻这个建议后，整个逻辑会显得很简单易懂，反正没有实现的，在子类就能找到实现
2，相互依赖调来调去的后果就是在系统越来越复杂以后，最后就没人能看懂了
3，防止抽象类的方法变动引起子类的改动，这个其实不算原因，因为一般来说，抽象类是比较稳定的，而且，子类可以调的抽象类方法在修改时肯定要考量子类的，不允许子类调用的方法肯定都处理过了，一般肯定是调不到的（诶，反射你凑过来干嘛？）
最后的最后，总结一下模板方法模式的优缺点吧
优点：
1，代码复用便于维护，子类可扩展
2，行为由父类控制，子类只需要关心自己所需要的步骤即可，开发难度低
缺点：
1，每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大
所以，如果发现子类很多，是不是要想想是不是设计模式用错了，去隔壁找找其他的设计模式吧