设计模式 - 模板方法模式(Template Method)

Template Method模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
• 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。
• 各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。

按照Template Method模式提炼方法来重构代码，是实现很多其它模式的基础。

案例 1： 以下通过一个冒泡排序(Bubble)程序一步一步重构提炼方法实现Template Method模式。
Step 1: 先写一个int数组的冒泡排序程序，验证算法

public class BubbleSorter{
	public int[] sort(int[] args) {
		if(args == null) return null;
		if(args.length <= 1) return args;
		for(int i = args.length-2; i > 0; i--) {
			for(int j = 0; j <= i; j++) {
				if(args[j] > args[j+1]) {
					int temp = args[j];
					args[j] = args[j+1];
					args[j+1] = temp;
				}
			}
		}
		return args;
	}
}

Step 2: 考虑到需要支持double数组的排序需求，对BubbleSorter类实施重构，先从提炼方法开始重构。

public class BubbleSorter{
	public int[] sort(int[] args) {
		if(args == null) return null;
		if(args.length <= 1) return args;
		for(int i = args.length-2; i > 0; i--) {
			for(int j = 0; j <= i; j++) {
				if(outOfOrder(args, j)) {
					swap(args, j);
				}
			}
		}
		return args;
	}
	
	private boolean outOfOrder(int[] args, int index) {
		return args[index] > args[index + 1];
	}
	
	private void swap(int[] args, int index) {
		int temp = args[index];
		args[index] = args[index+1];
		args[index+1] = temp;
	}
}

Step 3： 提炼出来的辅助方法swap 和outOfOrder的带一个数组参数，这样它们依赖于数组类型，考虑除去这个数组参数，需要添加一个成员变量来持有被排序的数组。

public class BubbleSorter {
	private int[] args;
	private int length = 0;
	public int[] sort(int[] args) {
		if(args == null) return null;
		this.args = args;
		length = args.length;
		if(length <= 1) return args;
		for(int i = length -2; i > 0; i--) {
			for(int j = 0; j <= i; j++) {
				if(outOfOrder(j)) {
					swap(j);
				}
			}
		}
		return args;
	}
	private boolean outOfOrder(int index) {//Extract Method
		return args[index] > args[index + 1];
	}
	
	private void swap(int index) {//Extract Method
		int temp = args[index];
		args[index] = args[index+1];
		args[index+1] = temp;
	}
}

Step 3： 可以看到sort方法中的for 循环语句不依赖于数组，再提炼方法。

public class BubbleSorter {
	private int[] args;
	private int length = 0;
	public int[] sort(int[] args) {
		if(args == null) return null;
		this.args = args;
		length = args.length;
		if(length <= 1) return args;
		doSort();
		return args;
	}
	private void doSort() {//Extract Method
		for(int i = length -2; i > 0; i--) {
			for(int j = 0; j <= i; j++) {
				if(outOfOrder(j)) {
					swap(j);
				}
			}
		}
	}
	private boolean outOfOrder(int index) {
		return args[index] > args[index + 1];
	}
	
	private void swap(int index) {
		int temp = args[index];
		args[index] = args[index+1];
		args[index+1] = temp;
	}
}

Step 4: 如论是Int数组还是double数组, 都会用到doSort, swap and outOfOrder方法，使用Template Method 模式，提炼抽象超类。

public abstract class AbstractBubbleSorter {
	protected int length = 0; //protected 
	public void doSort() {//template method
		for(int i = length -2; i > 0; i--) {
			for(int j = 0; j <= i; j++) {
				if(outOfOrder(j)) {
					swap(j);
				}
			}
		}
	}
	public abstract boolean outOfOrder(int index);
	public abstract void swap(int index);
}

Step 5: 将BubbleSorter更名成IntBubbleSorter并继承AbstractBubbleSorter类：

public class IntBubbleSorter extends AbstractBubbleSorter {
	private int[] args;
	public int[] sort(int[] args) {
		if(args == null) return null;
		this.args = args;
		length = args.length;
		if(length <= 1) return args;
		doSort();
		return args;
	}
	public boolean outOfOrder(int index) {
		return args[index] > args[index + 1];
	}
	
	public void swap(int index) {
		int temp = args[index];
		args[index] = args[index+1];
		args[index+1] = temp;
	}
}

同上写出 DoubleBubberSorter 类

Factory Method通常通过Template Method调用。

返回 模式与重构