策略模式Strategy

策略模式和状态模式比较类似。

状态模式是以状态驱动行为的模式，而策略模式则以算法驱动行为的模式，某个类存在着不同的状态且不同状态类的行为不同，则选择状态模式，如某个类的行为有几种不同的实现方式，则选择策略模式。

GOF定义：定义一族算法，将每个算法分别封装起来，并且相互之间可以替换。策略模式可以使不同算法之间的替换独立于使用算法的客户。策略模式是非常常用的模式。

 

角色分析：

Context（环境类）

  环境类是使用算法的角色，它用于解决问题时决定采用不同的策略，在环境类中维护一个抽象策略的引用。

AbstractStrategy（抽象策略类）

 用于定义算法的抽象，它是所有策略的父类，及对外提供的算法接口。

ConcreteStrategy（具体策略实现类）

 具体算法策略的实现。

 

 

例：排序算法

 

 

 

 

 

//环境角色
package context;

import abstract_algorich.AbstractSort;

/**
 *create by datao.wang 2014-2-7-下午2:44:11	
 */
public class SortContext {
	   public AbstractSort sort;
	   
	   public int[] sort(int[] array){
		   return sort.sort(array);
	   }
	
	   public void setSort(AbstractSort sort) {
		   this.sort = sort;
	   }
	   
   
}

 

//抽象策略
package abstract_algorich;


/**
 *create by datao.wang 2014-2-7-下午2:41:43	
 */
public interface AbstractSort {
 
	 public abstract int[] sort(int[] array);
}

 

//具体策略实现
package concrete_algorich;

import abstract_algorich.AbstractSort;

/**
 *create by datao.wang 2014-2-7-下午4:53:54	
 * 冒泡排序
 * 原理：不断重复进行元素的比较
 * 对于元素较多的数据不适用
 */
public class BubbleSort implements AbstractSort {

	@Override
	public int[] sort(int[] array) {
        for(int i=0;i<array.length;i++){
        	for(int j=i+1;j<array.length;j++){
        		int tmp;
        		if(array[i]>array[j]){
        			tmp=array[i];
        			array[i]=array[j];
        			array[j]=tmp;
        		}
        	}
        }
		return array;
	}

}

package concrete_algorich;

import abstract_algorich.AbstractSort;

/**
 *create by datao.wang 2014-2-7-下午4:04:29	
 *插入排序
 *原理：
 *  1、前两个元素，先第一个元素与第二元素比较，如果第一个元素大于第二元素则交换位置
 *  2、前三个元素进行排序
 *  3、前四个元素进行排序
 *  4、以此类推，一直到最后一个元素
 */
public class InsertionSort implements AbstractSort {

	@Override
	public int[] sort(int[] array) {
        int len=array.length;
        for(int i=1;i<len;i++){
        	int j;
        	int temp=array[i];
        	for(j=i;j>0;j--){
        		if(array[j-1]>temp){
        			array[j]=array[j-1];
        		}else{
        			break;
        		}
        	}
        	array[j]=temp;
        }
		return array;
	}

}

package concrete_algorich;

import abstract_algorich.AbstractSort;

/**
 *create by datao.wang 2014-2-7-下午3:04:49	
 *原理：
 *  1、在要排列的数组中寻找一个基数
 *  2、分区操作，将小于基数的放在前端，将大于基数的放在后端，等于基数放任意一端
 *  3、递归分区，分别前端和后端的数组再次进行分区操作，直到每端只有一个数。
 */
public class QuickSort implements AbstractSort {

	@Override
	public int[] sort(int[] array) {
        sort(array,0,array.length-1);
		return array;
	}
	
	/**
	 * create by datao.wang  2014-2-7
	 * @param a
	 * @param i
	 * @param j
	 * 交换数组的两个位置
	 */
	private void swap(int[] a,int i,int j){
		int t=a[i];
		a[i]=a[j];
		a[j]=t;
	}
	
	/**
	 * create by datao.wang  2014-2-7
	 * @param array
	 * @param p
	 * @param r
	 * @return
	 * 分区操作
	 */
	private int partition(int[] array ,int p,int r){
		int x=array[r]; //最后一个数作为基数
		int j=p-1;
		for(int i=p;i<=r-1;i++){
			if(array[i]<=x){ //将其他数与基数进行比较，如果比基数小则交换位置
				j++;
				swap(array,j,i);
			}
		}
		swap(array,j+1,r);
		return j+1;
	}
    
	/**
	 * create by datao.wang  2014-2-7
	 * @param array
	 * @param p
	 * @param r
	 * 排序
	 */
	private void sort(int array[],int p,int r){
		int q=0;
		if(p<r){
			q=partition(array, p, r);
			sort(array, p, q-1);
			sort(array,q+1,r);
		}
	}
}


package concrete_algorich;

import abstract_algorich.AbstractSort;

/**
 *create by datao.wang 2014-2-7-下午2:46:00	
 *选择排序
 *原理：在一个数组中先假设第一元素为最小（大）元素，然后将这个元素与剩余的元素进行比较
 *      如果遇上有元素比假设的值更小，则进行交换，否则不交换，将比较后较小的元素放在该
 *      数组（已排序）的后面，以此类推进行比较。
 */
public class SelectSort implements AbstractSort {

	@Override
	public int[] sort(int[] array) {
         int len=array.length;
         int temp;
         for(int i=0;i<len;i++){
        	 temp=array[i];//第一个假设值
        	 int j;
        	 int samllestLocation=i;
        	 for(j=i+1;j<len;j++){//剩余的元素
        		 if(array[j]<temp){
        			 temp=array[j];//进行比较交换
        			 samllestLocation=j;
        		 }
        	 }
        	 array[samllestLocation]=array[i];//交换元素位置
        	 array[i]=temp;//存放元素值
         }
		return array;
	}

}

 

import concrete_algorich.SelectSort;
import context.SortContext;

/**
 *create by datao.wang 2014-2-7-下午5:08:16	
 *客户端调用
 */
public class Client {
   public static void main(String[] args) {
	
	   int array[]=new int[]{1,3,5,2,3,5,3};
	   SortContext context=new SortContext();
	   context.setSort(new SelectSort());//这里的设置还可以配置到XML文件中
	   context.sort(array);
	   System.out.println(array.toString());
   }
}

 

优点：灵活，使使用者和具体的实现者之间解耦，使用不需要知道具体的算法。

缺点：使用者必须知道存在的策略，策略的增加会带来类的增加。