STRATEGY模式（冒泡算法为例）

STRATEGY模式

        STRATEGY模式使用了一种非常不同的方法来倒置通用算法和具体实现之间的依赖关系。

        不是将通用的应用算法放进一个抽象基类中，而是将它放进一个名为BubbleSorter的具体类中。我们把通用的算法必须要调用的抽象的方法定义一个SortHandle接口中。我们从这个接口派生出Intsorthandle，并传给BubbleSorter，之后BubbleSorter就可以吧具体工作委托给这个接口去完成。

BubbleSorter类

public class BubbleSorter {
        private int operations = 0;
        private int length = 0;
        private SortHandle itsSortHandle = null;

        public BubbleSorter(SortHandle handle)
        {
            itsSortHandle = handle;
        }

        public int sort(Object array)
        {
            itsSortHandle.setArray(array);
            length = itsSortHandle.length();
            operations = 0;
            if (length <= 1)
                return operations;

            for (int nextToLast = length-2; nextToLast >= 0; nextToLast--)
                for (int index = 0; index <= nextToLast; index++)
                {
                    if (itsSortHandle.outOfOrder(index))
                        itsSortHandle.swap(index);
                    operations++;
                }

            return operations;
        }

        public void printarr(int [] arr){
            for(int i=0;i<arr.length;i++) {
                System.out.print(arr[i]+"  ");
            }
            System.out.println();
        }


}

 SortHandle接口

public interface SortHandle {
    public void swap(int index);
    public boolean outOfOrder(int index);

    public int length();
    public void setArray(Object array);
}

Intsorthandle类（int类型的方法）还可以定义其他类型的类入：double float等。

public class IntHeapHandle implements HeapHandle{

    private int[] array = null;

    public void swap(int i, int j)
    {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public void setArray(Object array)
    {
        this.array = (int[])array;
    }

    public int length()
    {
        return array.length;
    }

    public boolean outOfOrder(int index)
    {
        return (array[index] < array[index+1]);
    }

    @Override
    public boolean lrOrder(int i, int j) {
        return (array[i] > array[j]);
    }
}

        请注意Intsorthandle类对BubbleSorter类是一无所知的。它不依赖于冒泡排序的任何实现方法。

        由于swap和outOfOrder方法中的实现是直接依赖于冒泡排序算法，而用SRETEGY方法不包含这样的依赖。因此可以在BubbleSorter之外的其他Sorter实现Intsorthandle。