Template pattern模板方法模式

1>模板模式定义了算法的步骤，把这些步骤的实现延续到子类

2>模板模式为我们提供了一个代码复用的技巧

3>模板抽象类中可以定义具体方法、抽象方法和钩子方法

4>为了防止子类改变模板中的算法，可以将模板方法声明为final

5>钩子是一种方法，它在抽象类中不做事，或只做默认的事，子类可以选择要不要实现它

模板方法模式，在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情冴下，重新定义算法中的某些步骤。

我们使用冲泡咖啡和冲泡茶的例子

加工流程：

咖啡冲泡法：1.把水煮沸、2.用沸水冲泡咖啡、3.把咖啡倒进杯子、4.加糖和牛奶

茶冲泡法：   1.把水煮沸、2.用沸水冲泡茶叶、3.把  茶 倒进杯子、4.加蜂蜜

实践步骤：

1>创建一个模板(抽象)类：Beverage(饮料)

1. package com.kaishengit.beverage;
2. public abstract class Beverage {
3. /**
4. * 冲泡咖啡或茶...流程
5. */
6. public final void create(){
7. boilWater();//把水煮沸
8. brew();//用沸水冲泡...
9. pourInCup();//把...倒进杯子
10. addCoundiments();//加...
11. }
12. public abstract void addCoundiments();
13. public abstract void brew();
14. public void boilWater() {
15. System.out.println("煮开水");
16. }
17. public void pourInCup() {
18. System.out.println("倒进杯子");
19. }
20. }

2>创建一个咖啡类(Coffee)和茶(Tea)类,都继承Beverage抽象类

1.咖啡(Coffee)

1. package com.kaishengit.beverage;
2. public class Coffee extends Beverage{
3. @Override
4. public void addCoundiments() {
5. System.out.println("添加糖和牛奶");   }
6. @Override
7. public void brew() {
8. System.out.println("用水冲咖啡");
9. }
10. }

2.茶(Tea)

1. package com.kaishengit.beverage;
2. public class Tea extends Beverage{
3. @Override
4. public void addCoundiments() {
5. System.out.println("添加蜂蜜");
6. }
7. @Override
8. public void brew() {
9. System.out.println("用水冲茶");
10. }
11. }

3.我们测试一下：

1. package com.kaishengit.beverage;
2. public class Test {
3. public static void main(String[] args) {
4. Coffee coffee = new Coffee();
5. coffee.create();//冲泡咖啡
6. //Tea tea = new Tea();//冲泡茶
7. //tea.create();
8. }
9. }

运行结果：

-----------------------------------

煮开水

用水冲咖啡

倒进杯子

添加糖和牛奶

-----------------------------------

在模版模式中使用挂钩(hook)

存在一个空实现的方法，我们称这种方法为”hook”。子类可以视情况来决定是否要覆盖它。

1>我们对模板类(Beverage)进行修改

1. package com.kaishengit.beverage;
2. public abstract class Beverage {
3. /**
4. * 冲泡咖啡或茶...流程
5. */
6. public final void create(){
7. boilWater();//把水煮沸
8. brew();//用沸水冲泡...
9. pourInCup();//把...倒进杯子
10. addCoundiments();//加...
11. hook();//挂钩
12. }
13. //空实现方法
14. public void hook(){}
15. public abstract void addCoundiments();
16. public abstract void brew();
17. public void boilWater() {
18. System.out.println("煮开水");
19. }
20. public void pourInCup() {
21. System.out.println("倒进杯子");
22. }
23. }

2>假如我们搞活动，喝一杯咖啡送一杯，修改咖啡(Coffee)类

1. package com.kaishengit.beverage;
2. public class Coffee extends Beverage{
3. @Override
4. public void addCoundiments() {
5. System.out.println("添加糖和牛奶");   }
6. @Override
7. public void brew() {
8. System.out.println("用水冲咖啡");
9. }
10. /**
11. * 挂钩
12. */
13. @Override
14. public void hook() {
15. System.out.println("再来一杯");
16. }
17. }

3>使用上面的测试类

运行结果：

--------------------------------

煮开水

用水冲咖啡

倒进杯子

添加糖和牛奶

再来一杯

--------------------------------

结果中有“再来一杯”...

我们也可以这样使用挂钩，让其决定里面的代码是否执行

1>我们对模板类(Beverage)进行修改

1. package com.kaishengit.beverage;
2. public abstract class Beverage {
3. /**
4. * 冲泡咖啡或茶...流程
5. */
6. public final void create(){
7. boilWater();//把水煮沸
8. brew();//用沸水冲泡...
9. pourInCup();//把...倒进杯子
10. //挂钩决定是否添加配料
11. if(hook()){
12. addCoundiments();//加...
13. }
14. //hook();
15. }
16. /**
17. * 默认添加配料
18. * @return
19. */
20. public boolean hook() {
21. return true;
22. }
23. //public void hook(){}
24. public abstract void addCoundiments();
25. public abstract void brew();
26. public void boilWater() {
27. System.out.println("煮开水");
28. }
29. public void pourInCup() {
30. System.out.println("倒进杯子");
31. }
32. }

2>我们对Coffee类进行修改，让其不添加配料

1. package com.kaishengit.beverage;
2. public class Coffee extends Beverage{
3. @Override
4. public void addCoundiments() {
5. System.out.println("添加糖和牛奶");   }
6. @Override
7. public void brew() {
8. System.out.println("用水冲咖啡");
9. }
10. /**
11. * 有的客人不喜欢加配料
12. */
13. @Override
14. public boolean hook() {
15. return false;
16. }
17. /*@Override
18. public void hook() {
19. System.out.println("再来一杯");
20. }
21. */
22. }

3>还是使用上面的测试类

运行结果：

------------------------------------------------------

煮开水

用水冲咖啡

倒进杯子

------------------------------------------------------

运行结果中没有添加配料

关于模板模式

1>模板模式定义了算法的步骤，把这些步骤的实现延迟到子类

2>模板模式为我们提供了一个代码复用的技巧

3>模板抽象类中可以定义具体方法、抽象方法和钩子方法

4>为了防止子类改变模板中的算法，可以将模板方法声明为final

5>钩子是一种方法，它在抽象类中不做事，或只做默认的事，子类可以选择要不要实现它