设计模式学习--模板方法模式(Tamplate Pattern)
-
封装变化
-
多用组合，少用继承
-
针对接口编程，不针对实现编程
-
为交互对象之间的松耦合设计而努力
-
类应该对扩展开放，对修改关闭
-
依赖抽象，不要依赖具体类
-
只和朋友交谈
-
别找我，我会找你（这是新的原则：由超类主控一切，当它们需要的时候，自然会去调用子类，这就跟好莱坞一样）
OO模式
模板模式——在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算结构的情况下，重新定义算法中的某些步骤。
模板方法模式要点
-
“模板方法”定义 算法的步骤，把这些步骤的实现延迟到子类。
-
模板方法模式为我们提供一种代码复用的重要技巧。
-
模板方法的抽象类可以定义具体方法、抽象方法和钩子。
-
抽象方法由子类实现。
-
钩子是一种方法，它在抽象类中不做事，或者只做默认的事情，子类可以选择要不要去覆盖它。
-
为了防止子类改变模板方法中的算法，可以将模板方法声明为final。
-
好莱坞原则告诉我们，将决策权放在高层模块中，以便决定如何以及何时调用低层模块。
-
你将在真实世界代码中看到模块方法模式的许多变体，不要期待它们全都是一眼就可以被你认出。
-
策略模式和模板方法模式都封装算法，一个用组合，一个用继承。
-
工厂方法是模板方法的一种特殊版本。
模板方法模式使用例子：泡茶和泡咖啡的冲泡
来点咖啡因吧
这是一个声明为抽象的类，里面定义了一个模板方法，两个由子类去实现的抽象方法
package simpleTamplateMethod;
/**
-
2013/6/27
-
@author wwj
-
模板方法模式
*/
public abstract class CaffineBeverage {
/**
-
模板方法
-
1.它是一个方法
-
2.它用作一个算法的模板，在这个例子中，算法是用来制作咖啡因饮料的
-
在这个模板中，算法内的每一个步骤都被一个方法代表了
*/
final void prepareRecipe() {
boilWater();
brew();
pourInCup();
addCondiments();
}
//需要子类提供的方法，必须要在超类中声明为抽象
abstract void brew();
abstract void addCondiments();
void boilWater() {
System.out.println(“Boiling water”);
}
void pourInCup() {
System.out.println(“Pouring into cup”);
}
Coffee和Tea两个类继承CaffineBeverage超类
package simpleTamplateMethod;
/**
-
咖啡继承咖啡因饮料
-
@author wwj
*/
public class Coffee extends CaffineBeverage {
@Override
void brew() {
System.out.println(“Dripping Coffee through filter”); //冲泡咖啡
}
@Override
void addCondiments() {
System.out.println(“Adding Sugar and Milk”); //增加糖和牛奶
}
}
package simpleTamplateMethod;
/**
-
茶类继承自咖啡因饮料
-
@author wwj
*/
public class Tea extends CaffineBeverage{
@Override
void brew() {
System.out.println(“Steeping the tea”); //泡茶
}
@Override
void addCondiments() {
System.out.println(“Adding Lemon”); //增加柠檬
}
}
测试一下
package simpleTamplateMethod;
public class CaffineBeverageTest {
public static void main(String[] args) {
System.out.println(“-------泡茶咯----------”);
Tea myTea = new Tea();
myTea.prepareRecipe(); //调用模板方法，就这样把所有工作做完了
System.out.println(“-------泡茶咯----------”);
System.out.println(“-------煮咖啡咯----------”);
Coffee myCoffee = new Coffee();
myCoffee.prepareRecipe();
System.out.println(“-------煮咖啡咯----------”);
}
}
测试结果
-------泡茶咯----------
Boiling water
Steeping the tea
Pouring into cup
Adding Lemon
-------泡茶咯----------
-------煮咖啡咯----------
Boiling water
Dripping Coffee through filter
Pouring into cup
Adding Sugar and Milk
-------煮咖啡咯----------
对模板方法进行挂钩
package hook;
/**
-
模块方法使用钩子
-
@author wwj
*/
public abstract class CaffineBeverageWithHook {
void prepareRecipe() {
boilWater();
brew();
pourInCup();
if(customerWantsCondiments()){ //加上这个条件，通过一个具体方法来决定是否执行语句，这就是对模块方法进行挂钩
addCondiments();
}
}
abstract void brew();
abstract void addCondiments();
void boilWater() {
System.out.println(“Boilng water”);
}
void pourInCup() {
System.out.println(“Pouring into cup”);
}
/**
-
这就是钩子
-
@return
*/
boolean customerWantsCondiments() {
return true;
}
}
package hook;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class CoffeeWithHook extends CaffineBeverageWithHook {
@Override
void brew() {
System.out.println(“Dripping Coffee through filter”);
}
@Override
void addCondiments() {
System.out.println(“Adding Sugar and Milk”);
}
/**
- 覆盖这个钩子函数，提供自己的功能
*/
public boolean customerWantsCondiments() {
String answer = getUserInput();
if(answer.toLowerCase().startsWith(“y”)){
return true;
} else {
return false;
}
}
private String getUserInput() {
String answer = null;
System.out.println("Would you like milk and sugar with your coffee (y/n)? ");
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
try {
answer = in.readLine();
} catch (IOException e) {
System.out.println(“IO error trying to read your answer”);
}
if(answer == null) {
return “no”;
}
return answer;
}
}