模板方法模式

介绍

  GoF 23种设计模式之一。

定义

  定义一个操作中算法的框架，而将一些步骤延迟到子类中，使得子类可以不改变算法的结构即可重定义该算法中的某些特定步骤。

举例

排序抽象类

public abstract class AbstractSort {
	protected abstract void sort(int[] array);
	/**
	 * 模板方法
	 * 
	 * @param array
	 */
	protected final void templateMethod(int[] array) {
		sort(array);
	}
}

冒泡排序

public class BubbleSort extends AbstractSort {
	@Override
	protected void sort(int[] array) {
		int len = array.length;
		int i, j, temp;
		for (j = 0; j < len; j++) {
			for (i = 0; i < len - 1; i++) {
				if (array[i] > array[i + 1]) {
					temp = array[i];
					array[i] = array[i + 1];
					array[i + 1] = temp;
				}
			}
		}
	}
}

快速排序

public class QuickSort extends AbstractSort {

	@Override
	protected void sort(int[] array) {
		quick(array, 0, array.length - 1);
	}

	protected void quick(int[] r, int left, int right) {
		int low = left, high = right;
		int key = r[left];
		int temp;
		while (low < high) {
			while (low < high && r[high] >= key) {
				high--;
			}
			while (low < high && r[low] <= key) {
				low++;
			}
			if (low < high) {
				temp = r[low];
				r[low] = r[high];
				r[high] = temp;
			}
		}
		r[left] = r[low];
		r[low] = key;
		if (left < low)
			quick(r, left, low - 1);
		if (right > high)
			quick(r, high + 1, right);
	}

}

测试

public class Demo {
	public static void main(String[] args) {
		System.out.println("冒泡排序");
		int a[] = { 4, 3, 2, 7, 6, 1, 8, 5, 10, 9 };
		AbstractSort sort = new BubbleSort();
		sort.templateMethod(a);
		// 输出数据
		for (int i = 0; i < a.length; i++) {
			if (i == a.length - 1) {
				System.out.println(a[i]);
			} else {
				System.out.print(a[i] + ",");
			}
		}
		System.out.println("快速排序");
		a = new int[] { 4, 3, 2, 7, 6, 1, 8, 5, 10, 9 };
		sort = new QuickSort();
		sort.templateMethod(a);
		// 输出数据
		for (int i = 0; i < a.length; i++) {
			if (i == a.length - 1) {
				System.out.println(a[i]);
			} else {
				System.out.print(a[i] + ",");
			}
		}
	}
}

执行结果

适用场景

1. 每一个子类中都重写了父类通用的方法；
2. 重要且复杂的算法，核心算法设计为模板算法。