模板方法：
定义一个算法的大纲，而由其子类定义其中某些步骤的内容。而其算法的个别步骤可以有不同的实现细节。算法结构依然维持不变。用继承的方式改变算法中的具体步骤，依赖程度高，算法在父类（父类是抽象类）中实现，算法的具体步骤在子类中实现。
策略模式：
定义一个算法家族，并让这些算法可以互换。用组合的方式改变整个算法，依赖程度低，父类是接口类，算法在子类中具体实现。
示例冒泡算法：
模板方法有三个类具体代码如下：
package asdppp.TmBSorter;
//父类为抽象类
public abstract class BubbleSorter
{
private int operations = 0;
//使用protected是为了让子类可以赋值
protected int length = 0;
//封装了抽象的冒泡算法，之所以是抽象的因为在这个算法中swap（怎么交换）、outOfOrder（是否交换）被抽象出来了
protected int doSort()
{
operations = 0;
if (length <= 1)
return operations;
for (int nextToLast = length-2; nextToLast >= 0; nextToLast--)
for (int index = 0; index <= nextToLast; index++)
{
if (outOfOrder(index))
swap(index);
operations++;
}
return operations;
}
//算法中的swap、outOfOrder两个步骤需要子类具体实现对哪些array进行操作
protected abstract void swap(int index);
protected abstract boolean outOfOrder(int index);
}
第一个子类
package asdppp.TmBSorter;
//继承父类也就继承了其算法
public class DoubleBubbleSorter extends BubbleSorter
{
private double[] array = null;
//两个子类使用了父类的算法，两个子类的数据类型参数是swap和outOfOrder虽然代码相同但其实不同
public int sort(double [] theArray)
{
array = theArray;
//对父类算法的length进行赋值
length = array.length;
return doSort();
}
//具体实现了其算法中的具体步骤swap、outOfOrder，其实本例中子类的这两个代码是一样的
protected void swap(int index)
{
double temp = array[index];
array[index] = array[index+1];
array[index+1] = temp;
}
protected boolean outOfOrder(int index)
{
return (array[index] > array[index+1]);
}
}
第二个子类
package asdppp.TmBSorter;
//继承父类也就继承了其算法
public class IntBubbleSorter extends BubbleSorter
{
private int[] array = null;
public int sort(int [] theArray)
{
array = theArray;
length = array.length;
return doSort();
}
//具体实现了其算法中的具体步骤swap、outOfOrder
protected void swap(int index)
{
int temp = array[index];
array[index] = array[index+1];
array[index+1] = temp;
}
protected boolean outOfOrder(int index)
{
return (array[index] > array[index+1]);
}
}
测试类
package asdppp.TmBSorter;
import junit.framework.TestCase;
public class TestBubbleSort extends TestCase
{
public static void main(String[] args)
{
junit.swingui.TestRunner.main(args);
}
public TestBubbleSort(String name)
{
super(name);
}
public void testEmptyIntArray()
{
int[] array = new int[0];
int operations = (new IntBubbleSorter()).sort(array);
assertEquals(0, operations);
}
public void testIntArrayWithOneElement()
{
int[] array = {0};
int operations = (new IntBubbleSorter()).sort(array);
assertEquals(0, operations);
assertEquals(0, array[0]);
assertEquals(1, array.length);
}
public void testIntArrayWithTwoInOrderElements()
{
int[] array = {0,1};
int operations = (new IntBubbleSorter()).sort(array);
assertEquals("operations",1, operations);
assertEquals(0, array[0]);
assertEquals(1, array[1]);
assertEquals(2, array.length);
}
public void testIntArrayWithTwoOutOfOrderElements()
{
int[] array = {1,0};
int operations = (new IntBubbleSorter()).sort(array);
assertEquals("operations",1, operations);
assertEquals("array[0]", 0, array[0]);
assertEquals("array[1]", 1, array[1]);
assertEquals(2, array.length);
}
public void testIntArrayWithThreeOutOfOrderElements()
{
int[] array = {3,2,1};
int operations = (new IntBubbleSorter()).sort(array);
assertEquals("operations", 3, operations);
assertEquals("array[0]", 1, array[0]);
assertEquals("array[1]", 2, array[1]);
assertEquals("array[2]", 3, array[2]);
assertEquals(3, array.length);
}
public void testIntArrayWithTenOutOfOrderElements()
{
int[] array = {9,8,7,6,5,4,3,2,1,0};
int operations = (new IntBubbleSorter()).sort(array);
assertEquals("operations", 45, operations);
for (int i=0; i<10; i++)
assertEquals("array["+i+"]", i, array[i]);
}
public void testDoubleArrayWithTenOutOfOrderElements()
{
double[] array = {9,8,7,6,5,4,3,2,1,0};
int operations = (new DoubleBubbleSorter()).sort(array);
assertEquals("operations", 45, operations);
for (int i=0; i<10; i++)
assertEquals("array["+i+"]", i, array[i], .001);
}
}
由代码可以看出算法被父类抽象出来了，具体的比如数组的长度、具体数组类型、如何交换、判断是否交换等都在子类里实现。
