JAVA设计模式之【策略模式】

策略模式
	定义一些独立的类来封装不同的算法
	类似于common方法或者引用类
	角色
		环境类Context
		抽象策略Strategy
		具体策略ConcreteStrategy
	重构伴随着设计模式
		重构类结构
		重构文件名称，变量名称
		重构算法

看例子，排序算法策略

1.抽象策略

package Strategy;

/**
 * Created by Jiqing on 2016/10/30.
 */
public interface Sort {
    public abstract int[] sort(int arr[]);
}

2.具体排序算法，具体策略

package Strategy;

/**
 * Created by Jiqing on 2016/10/30.
 */
public class BubbleSort implements Sort{ // 冒泡排序策略
    public int[] sort(int arr[]) {
        int len = arr.length;
        for(int i=0;i<len;i++)
        {
            for(int j=i+1;j<len;j++)
            {
                int temp;
                if(arr[i]>arr[j])
                {
                    temp=arr[j];
                    arr[j]=arr[i];
                    arr[i]=temp;
                }
            }
        }
        System.out.println("冒泡排序");
        return arr;
    }
}

package Strategy;

/**
 * Created by Jiqing on 2016/10/30.
 */
public class InsertionSort implements Sort{
    public int[] sort(int arr[])
    {
        int len=arr.length;
        for(int i=1;i<len;i++)
        {
            int j;
            int temp=arr[i];
            for(j=i;j>0;j--)
            {
                if(arr[j-1]>temp)
                {
                    arr[j]=arr[j-1];

                }else
                    break;
            }
            arr[j]=temp;
        }
        System.out.println("插入排序");
        return arr;
    }
}

package Strategy;

/**
 * Created by Jiqing on 2016/10/30.
 */
public class QuickSort implements Sort{
    public int[] sort(int arr[])
    {
        System.out.println("快速排序");
        sort(arr,0,arr.length-1);
        return arr;
    }

    public void sort(int arr[],int p, int r)
    {
        int q=0;
        if(p<r)
        {
            q=partition(arr,p,r);
            sort(arr,p,q-1);
            sort(arr,q+1,r);
        }
    }

    public int partition(int[] a, int p, int r)
    {
        int x=a[r];
        int j=p-1;
        for(int i=p;i<=r-1;i++)
        {
            if(a[i]<=x)
            {
                j++;
                swap(a,j,i);
            }
        }
        swap(a,j+1,r);
        return j+1;
    }

    public void swap(int[] a, int i, int j)
    {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

package Strategy;

/**
 * Created by Jiqing on 2016/10/30.
 */
public class SelectionSort implements Sort
{
    public int[] sort(int arr[])
    {
        int len=arr.length;
        int temp;
        for(int i=0;i<len;i++)
        {
            temp=arr[i];
            int j;
            int samllestLocation=i;
            for(j=i+1;j<len;j++)
            {
                if(arr[j]<temp)
                {
                    temp=arr[j];
                    samllestLocation=j;
                }
            }
            arr[samllestLocation]=arr[i];
            arr[i]=temp;
        }
        System.out.println("选择排序");
        return arr;
    }
}

3.使用环境类

package Strategy;

/**
 * Created by Jiqing on 2016/10/30.
 */
public class ArrayHandler { // 环境类
    private Sort sortObj;
    public int[] sort(int arr[]) { // 基本功能
        sortObj.sort(arr);
        return arr;
    }

    public void setSortObj(Sort sortObj) {  // 设置策略
        this.sortObj = sortObj;
    }
}

4.客户端

package Strategy;

/**
 * Created by Jiqing on 2016/10/30.
 */
public class Client {
    public static void main(String args[])
    {
        int arr[]={1,4,6,2,5,3,7,10,9};
        int result[];
        ArrayHandler ah=new ArrayHandler();

        Sort sort;
        sort=new BubbleSort();

        ah.setSortObj(sort); //设置具体策略
        result=ah.sort(arr);

        for(int i=0;i<result.length;i++)
        {
            System.out.print(result[i] + ",");
        }
    }
}

结果：
冒泡排序
1,2,3,4,5,6,7,9,10

改造客户端

package Strategy;

/**
 * Created by Jiqing on 2016/10/30.
 */
public class Client {
    public static void main(String args[])
    {
        int arr[]={1,4,6,2,5,3,7,10,9};
        int result[],quickresult[];
        ArrayHandler ah=new ArrayHandler();

        Sort bubblesort,quicksort;
        bubblesort=new BubbleSort();
        quicksort= new QuickSort();

        ah.setSortObj(bubblesort); //设置具体策略
        result=ah.sort(arr);

        printArr(result);

        ah.setSortObj(quicksort);
        quickresult=ah.sort(arr);

        printArr(quickresult);

    }

    public static void printArr(int arr[]) { // 必须是静态函数才能被主函数直接调用
        for(int i=0;i<arr.length;i++)
        {
            if (i == arr.length-1) {
                System.out.print(arr[i]);
                System.out.println();

            } else {
                System.out.print(arr[i] + ",");
            }
        }
    }
}

结果：
冒泡排序
1,2,3,4,5,6,7,9,10
快速排序
1,2,3,4,5,6,7,9,10

看类图