策略模式

策略模式

一、定义

是对算法的包装，把使用算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类型的子类型。就是：“准备一组算法，并将每一个算法封装起来，使得他们可以互换。”

二、类图



意图：针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得他们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。

策略模式简单来说，就是将可能会被调用的多种方法封装进一个策略类中，当用户需要使用其中的某一种方法时，可以通过调用策略类来调用需要的算法。

三、实例

public class StrategyDemo {
public static void main(String[] args) {
int[] array = {6, 45, 12, 3, 22, 11, 90, 64};

ISort bubbleSort = new BubbleSort();
Context c = new Context(bubbleSort);
c.sort(array);
c.printArray(array);

ISort selectSort = new SelectSort();
Context c2 = new Context(selectSort);
c2.sort(array);
c2.printArray(array);
}
}

class Context{
private ISort is = null;
public Context(ISort isort){
this.is = isort;
}

public void sort(int[] array){
//交给具体的对象来排序
is.sort(array);
}

public void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}

}

interface ISort{
public void sort(int[] array);
}

//封装的冒泡排序法
class BubbleSort implements ISort{

@Override
public void sort(int[] array) {
System.out.println("冒泡排序法");
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-i-1; j++) {
if(array[j] > array[j+1]){
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
}
//选择排序法
class SelectSort implements ISort{

@Override
public void sort(int[] array) {
System.out.println("选择排序法");
int min = 0;
for (int i = 0; i < array.length; i++) {
min = i;
for (int j = i+1; j < array.length; j++) {
if(array[min] > array[j]){
min = j;
}
}
if(i != min){
int temp = array[i];
array[i] = array[min];
array[min] = temp;
}
}
}
}

四、优缺点

优点：
　　1、 提供了一种替代继承的方法，而且既保持了继承的优点(代码重用)还比继承更灵活(算法独立，可以任意扩展)。
　　2、 避免程序中使用多重条件转移语句，使系统更灵活，并易于扩展。
　　3、 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。
　　缺点：
　　1、 因为每个具体策略类都会产生一个新类，所以会增加系统需要维护的类的数量。

2、每次产生或删除一个具体方法类时，还需要对策略类进行同步到更改，破坏了程序的封装性。