模板模式，顧名思義，就是通過模板拓印的方式。
定義模板，就是定義框架、結構、原型。定義一個我們共同遵守的約定。
定義了模板，我們的剩余工作就是對其進行充實、豐潤，完善它的不足之處。
定義模板采用抽象類來定義，公共的結構化邏輯需要在抽象類中完成，只將非公共的部分邏輯抽象成抽象方法，留待子類充實實現。
所以上文所述不足之處就是這些抽象方法。
總的來說，模板模式就是通過抽象類來定義一個邏輯模板，邏輯框架、邏輯原型，然后將無法決定的部分抽象成抽象類交由子類來實現，一般這些抽象類的調用邏輯還是在抽象類中完成的。這么看來，模板就是定義一個框架，比如蓋房子，我們定義一個模板：房子要封閉，有門，有窗等等，但是要什么樣的門，什么樣的窗，這些並不在模板中描述，這個交給子類來完善，比如門使用防盜門，窗使用北向的窗等等。
我們不凡就以建房為例來見識一下模板模式如何：
模板抽象類：HouseTemplate
1 public abstract class HouseTemplate {
2
3 protected HouseTemplate(String name){
4 this.name = name;
5 }
6
7 protected String name;
8
9 protected abstract void buildDoor();
10
11 protected abstract void buildWindow();
12
13 protected abstract void buildWall();
14
15 protected abstract void buildBase();
16
17 //公共邏輯
18 public final void buildHouse(){
19
20 buildBase();
21 buildWall();
22 buildDoor();
23 buildWindow();
24
25 }
26
27 }
子類1：HouseOne
2
3 HouseOne(String name){
4 super(name);
5 }
6
7 @Override
8 protected void buildDoor() {
9 System.out.println(name +"的門要采用防盜門");
10 }
11
12 @Override
13 protected void buildWindow() {
14 System.out.println(name + "的窗戶要面向北方");
15 }
16
17 @Override
18 protected void buildWall() {
19 System.out.println(name + "的牆使用大理石建造");
20 }
21
22 @Override
23 protected void buildBase() {
24 System.out.println(name + "的地基使用鋼鐵地基");
25 }
26
27 }
子類2：HouseTwo
1 public class HouseTwo extends HouseTemplate {
2
3 HouseTwo(String name){
4 super(name);
5 }
6
7 @Override
8 protected void buildDoor() {
9 System.out.println(name + "的門采用木門");
10 }
11
12 @Override
13 protected void buildWindow() {
14 System.out.println(name + "的窗戶要向南");
15 }
16
17 @Override
18 protected void buildWall() {
19 System.out.println(name + "的牆使用玻璃制造");
20 }
21
22 @Override
23 protected void buildBase() {
24 System.out.println(name + "的地基使用花崗岩");
25 }
26
27 }
測試類：Clienter
1 public class Clienter {
2
3 public static void main(String[] args){
4 HouseTemplate houseOne = new HouseOne("房子1");
5 HouseTemplate houseTwo = new HouseTwo("房子2");
6 houseOne.buildHouse();
7 houseTwo.buildHouse();
8 }
9
10 }
測試結果：
房子1的地基使用鋼鐵地基 房子1的牆使用大理石建造 房子1的門要采用防盜門 房子1的窗戶要面向北方 房子2的地基使用花崗岩 房子2的牆使用玻璃制造 房子2的門采用木門 房子2的窗戶要向南
房子1的地基使用鋼鐵地基 房子1的牆使用大理石建造 房子1的門要采用防盜門 房子1的窗戶要面向北方 房子2的地基使用花崗岩 房子2的牆使用玻璃制造 房子2的門采用木門 房子2的窗戶要向南
通過以上例子，我們認識了模板模式中的基本方法和模板方法，其中HouseTemplate中的buildHouse方法就是基本方法，其余四個均為模板方法。其中基本方法一般會用final修飾，保證其不會被子類修改，而模板方法則使用protected修飾，表明其需要在子類中實現。
其實，模板模式中還有一個鈎子方法的概念，有人稱，具有鈎子方法的模板模式才算完整，也許吧。
鈎子方法時干啥的呢？鈎子就是給子類一個授權，允許子類通過重寫鈎子方法來顛覆基本邏輯的執行，這有時候是非常有用的。就比如在蓋房子的時候，有一個需要子類來決定是否建造廁所間的需求時，可以這么實現：
模板抽象類：HouseTemplate
1 public abstract class HouseTemplate {
2
3 protected HouseTemplate(String name){
4 this.name = name;
5 }
6
7 protected String name;
8
9 protected abstract void buildDoor();
10
11 protected abstract void buildWindow();
12
13 protected abstract void buildWall();
14
15 protected abstract void buildBase();
16
17 protected abstract void buildToilet();
18
19 //鈎子方法
20 protected boolean isBuildToilet(){
21 return true;
22 }
23
24 //公共邏輯
25 public final void buildHouse(){
26
27 buildBase();
28 buildWall();
29 buildDoor();
30 buildWindow();
31 if(isBuildToilet()){
32 buildToilet();
33 }
34 }
35
36 }
子類1：HouseOne
1 public class HouseOne extends HouseTemplate {
2
3 HouseOne(String name){
4 super(name);
5 }
6
7 HouseOne(String name, boolean isBuildToilet){
8 this(name);
9 this.isBuildToilet = isBuildToilet;
10 }
11
12 public boolean isBuildToilet;
13
14 @Override
15 protected void buildDoor() {
16 System.out.println(name +"的門要采用防盜門");
17 }
18
19 @Override
20 protected void buildWindow() {
21 System.out.println(name + "的窗戶要面向北方");
22 }
23
24 @Override
25 protected void buildWall() {
26 System.out.println(name + "的牆使用大理石建造");
27 }
28
29 @Override
30 protected void buildBase() {
31 System.out.println(name + "的地基使用鋼鐵地基");
32 }
33
34 @Override
35 protected void buildToilet() {
36 System.out.println(name + "的廁所建在東南角");
37 }
38
39 @Override
40 protected boolean isBuildToilet(){
41 return isBuildToilet;
42 }
43
44 }
子類2：HouseTwo
public class HouseTwo extends HouseTemplate {
HouseTwo(String name){
super(name);
}
@Override
protected void buildDoor() {
System.out.println(name + "的門采用木門");
}
@Override
protected void buildWindow() {
System.out.println(name + "的窗戶要向南");
}
@Override
protected void buildWall() {
System.out.println(name + "的牆使用玻璃制造");
}
@Override
protected void buildBase() {
System.out.println(name + "的地基使用花崗岩");
}
@Override
protected void buildToilet() {
System.out.println(name + "的廁所建在西北角");
}
}
測試類：Clienter
1 public class Clienter {
2
3 public static void main(String[] args){
4 HouseTemplate houseOne = new HouseOne("房子1", false);
5 HouseTemplate houseTwo = new HouseTwo("房子2");
6 houseOne.buildHouse();
7 houseTwo.buildHouse();
8 }
9
10 }
測試結果：
房子1的地基使用鋼鐵地基
房子1的牆使用大理石建造
房子1的門要采用防盜門
房子1的窗戶要面向北方
房子2的地基使用花崗岩
房子2的牆使用玻璃制造
房子2的門采用木門
房子2的窗戶要向南
房子2的廁所建在西北角
房子1的地基使用鋼鐵地基 房子1的牆使用大理石建造 房子1的門要采用防盜門 房子1的窗戶要面向北方 房子2的地基使用花崗岩 房子2的牆使用玻璃制造 房子2的門采用木門 房子2的窗戶要向南 房子2的廁所建在西北角
通過直接結果我們可以清晰的看到，我們通過重寫鈎子方法自定義了房子1不需要建造廁所（fasle）。
鈎子方法的作用也就一目了然啦。
模板模式的關鍵點：
1、使用抽象類定義模板類，並在其中定義所有的基本方法、模板方法，鈎子方法，不限數量，以實現功能邏輯為主。其中基本方法使用final修飾，其中要調用基本方法和鈎子方法，基本方法和鈎子方法可以使用protected修飾，表明可被子類修改。
2、定義實現抽象類的子類，重寫其中的模板方法，甚至鈎子方法，完善具體的邏輯。
使用場景：
1、在多個子類中擁有相同的方法，而且邏輯相同時，可以將這些方法抽出來放到一個模板抽象類中。
2、程序主框架相同，細節不同的情況下，也可以使用模板方法。