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

设计模式学习--模板方法模式(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