设计模式系列之九模板方法模式

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

  有一个泡茶和冲咖啡的业务，他们都有差不多相似的流程。

一、不使用设计模式

public class Tea {
	//泡茶流程
	void process() {
		boilWater();
		steepTeaBag();
		pourInCup();
		addLemon();
	}

	public void boilWater() {
		System.out.println("烧水");
	}

	public void steepTeaBag() {
		System.out.println("泡茶");
	}

	public void pourInCup() {
		System.out.println("倒进杯子");
	}

	public void addLemon() {
		System.out.println("加柠檬");
	}
}

public class Coffee {
	//冲咖啡流程
	void process() {
		boilWater();
		brewCoffeeGrinds();
		pourInCup();
		addSugarAndMilk();
	}

	public void boilWater() {
		System.out.println("烧水");
	}

	public void brewCoffeeGrinds() {
		System.out.println("冲咖啡");
	}

	public void pourInCup() {
		System.out.println("倒进杯子");
	}

	public void addSugarAndMilk() {
		System.out.println("加牛奶和糖");
	}
}

二、模板方法模式的使用

  下面以一个代码样例来说明模板方法模式的使用。

//定义模板方法
public abstract class TemplateMethod {
	//冲咖啡和泡茶的模板，注意这里的final,意味着该方法不可修改，即模板中方法的先后顺序被固定
	final void template() {
		//烧水
		boilWater();
		//冲泡：用沸水"浸泡"茶叶/用沸水"冲泡"咖啡
		brew();
		//把泡好的饮料倒进杯子
		pourInCup();
		//加调料
		addCondiments();
	}
	/**这两个方法交给子类去实现**/
	//茶应该"浸泡"，咖啡应该"冲泡"
	abstract void brew();
	//茶加柠檬，咖啡加牛奶和糖
	abstract void addCondiments();

	/**这两个方法属于公用方法**/
	void boilWater() {
		System.out.println("烧水");
	}
	void pourInCup() {
		System.out.println("倒进杯子");
	}
}

public class Tea extends TemplateMethod {
	public void brew() {
		System.out.println("浸泡");
	}
	public void addCondiments() {
		System.out.println("加柠檬");
	}
}

public class Coffee extends TemplateMethod {
	public void brew() {
		System.out.println("冲泡");
	}
	public void addCondiments() {
		System.out.println("加糖和牛奶");
	}
}

public class Test {
	public static void main(String[] args) {
		Tea tea = new Tea();
		Coffee coffee = new Coffee();
		//泡茶
		tea.template();
		//冲咖啡
		coffee.template();
	}
}

三、使用钩子(hook)来做一些其它操作

//定义模板方法
public abstract class TemplateMethodWithHook {
	//冲咖啡和泡茶的模板，注意这里的final,意味着该方法不可修改，即模板中方法的先后顺序被固定
	final void template() {
		//烧水
		boilWater();
		//冲泡：用沸水"浸泡"茶叶/用沸水"冲泡"咖啡
		brew();
		//把泡好的饮料倒进杯子
		pourInCup();
		//加调料
		if (customerWantsCondiments()) {
			addCondiments();
		}
	}
	/**这两个方法交给子类去实现**/
	//茶应该"浸泡"，咖啡应该"冲泡"
	abstract void brew();
	//茶加柠檬，咖啡加牛奶和糖
	abstract void addCondiments();

	/**这两个方法属于公用方法**/
	void boilWater() {
		System.out.println("烧水");
	}
	void pourInCup() {
		System.out.println("倒进杯子");
	}

	//这里是个钩子，子类可决定是否需要加调料。也就是说子类可通过这个hook控制模板定义的逻辑
	boolean customerWantsCondiments() {
		return true;
	}
}

public class TeaWithHook extends TemplateMethod {

	public void brew() {
		System.out.println("浸泡");
	}
	public void addCondiments() {
		System.out.println("加柠檬");
	}

	public boolean customerWantsCondiments() {
		//不需要加柠檬
		return false;
	}
}

public class CoffeeWithHook extends TemplateMethod {

	public void brew() {
		System.out.println("冲泡");
	}
	public void addCondiments() {
		System.out.println("加糖和牛奶");
	}

	public boolean customerWantsCondiments() {
		//需要加糖和牛奶
		return true;
	}
}

public class TestHook {
	public static void main(String[] args) {
		TeaWithHook teaHook = new TeaWithHook();
		CoffeeWithHook coffeeHook = new CoffeeWithHook();
		//泡茶，不加柠檬
		teaHook.template();
		//冲咖啡，加糖和牛奶
		coffeeHook.template();
	}
}

四、比较

不使用设计模式	使用模板方法模式
Coffee和Tea主导一切；它们控制了算法	TemplateMethod控制了一切，它拥有算法，并且保护这个算法
Coffee和Tea之间存在着重复的代码	通过TemplateMethod类实现了代码的复用
如果算法变了，需要修改Coffee和Tea类	新增算法或调整顺序只需要修改TemplateMethod类
由于类的组织不具有弹性，新加入第三种类型时需要完全重写一份	由于有模板存在，只需要实现差异化的逻辑即可
算法的知识和它的实现会分散在许多类中	TemplateMethod类专注在算法本身，而由子类提供完整的实现

上一篇：设计模式系列之八外观模式
下一篇：设计模式系列之十迭代器模式

留言

欢迎交流想法。留言会通过 GitHub Issues 保存，首次使用需要登录 GitHub。