设计模式之模板方法和策略模式的区别(一)

模板方法：

定义一个算法的大纲，而由其子类定义其中某些步骤的内容。而其算法的个别步骤可以有不同的实现细节。算法结构依然维持不变。用继承的方式改变算法中的具体步骤，依赖程度高，算法在父类（父类是抽象类）中实现，算法的具体步骤在子类中实现。

策略模式：

定义一个算法家族，并让这些算法可以互换。用组合的方式改变整个算法，依赖程度低，父类是接口类，算法在子类中具体实现。

示例冒泡算法：

模板方法有三个类具体代码如下：

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);
}

}

由代码可以看出算法被父类抽象出来了，具体的比如数组的长度、具体数组类型、如何交换、判断是否交换等都在子类里实现。