设计模式学习--模板方法模式(Tamplate Pattern)

时间：2021-09-24 18:46:13

设计模式学习--模板方法模式(Tamplate Pattern)

2013年6月27日设计模式学习
回顾知识+新的模式

OO基础

  • 抽象
  • 封装
  • 多态
  • 继承
OO原则
  • 封装变化
  • 多用组合，少用继承
  • 针对接口编程，不针对实现编程
  • 为交互对象之间的松耦合设计而努力
  • 类应该对扩展开放，对修改关闭
  • 依赖抽象，不要依赖具体类
  • 只和朋友交谈
  • 别找我，我会找你（这是新的原则：由超类主控一切，当它们需要的时候，自然会去调用子类，这就跟好莱坞一样）
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;
}
}

package hook;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TeaWithHook extends CaffineBeverageWithHook {

@Override
void brew() {
System.out.println("Steeping the tea");
}

@Override
void addCondiments() {
System.out.println("Adding Lemon");
}
/**
 * 覆盖这个钩子函数，提供自己的功能
 */
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 lemon with your tea (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;
}
}

package hook;

public class BeverageTestDrive {
public static void main(String[] args) {
TeaWithHook teaHook = new TeaWithHook();
CoffeeWithHook coffeeWithHook = new CoffeeWithHook();

System.out.println("\nMaking tea...");
teaHook.prepareRecipe();


System.out.println("\nMaking coffee...");
coffeeWithHook.prepareRecipe();

}
}

测试结果： Making tea...
Boilng water
Steeping the tea
Pouring into cup
Would you like lemon with your tea (y/n)? 
y
Adding Lemon


Making coffee...
Boilng water
Dripping Coffee through filter
Pouring into cup
Would you like milk and sugar with your coffee (y/n)? 
y
Adding Sugar and Milk


标签：

相关文章