Template pattern模板方法模式

标签：

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

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

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

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

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

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

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

加工流程：

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

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

实践步骤：

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

Java代码  

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

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

1.咖啡(Coffee)

Java代码  

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

2.茶(Tea)

Java代码  

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

 3.我们测试一下：

Java代码  

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

 运行结果：

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

煮开水

用水冲咖啡

倒进杯子

添加糖和牛奶

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

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

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

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

Java代码  

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

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

Java代码  

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

 3>使用上面的测试类

运行结果：

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

煮开水

用水冲咖啡

倒进杯子

添加糖和牛奶

再来一杯

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

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

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

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

Java代码  

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

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

Java代码  

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

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

运行结果：

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

煮开水

用水冲咖啡

倒进杯子

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

运行结果中没有添加配料

关于模板模式

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

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

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

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

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

Template pattern模板方法模式

标签：

原文地址：http://www.cnblogs.com/wxishang1991/p/5220526.html