策略模式

2021-09-09

一、概述

策略模式中通过一些独立的类来封装不同的算法，每一个类封装一种具体的算法，每一个封装算法的类都称为一种策略。策略模式的定义为：定义一系列算法类，将每一个算法封装起来，并让它们可以相互替换，策略模式让算法独立于使用它的客户而变化，也称为政策模式。

策略模式是一种对象行为型模式。

策略模式结构图为：

二、代码设计

策略模式包括环境类Context、抽象策略类Strategy以及具体策略类ConcreteStrategy。

抽象策略类典型代码如下：

1
2
3

public abstract class AbstractStrategy {
  public abstract void algorithm(); //声明抽象算法
}

将封装每一种具体算法的类作为抽象策略类的子类，典型代码如下：

public class ConcreteStrategyA extends AbstractStrategy {
  //具体算法实现
  public void algorithm() {
    //算法A
  }
}

Context类会与抽象策略类之间建立一个关联关系，典型代码如下：

public class Context {
  private AbstractStrategy strategy; //维持一个对抽象策略类的引用
  
  public void setStrategy(AbstractStrategy strategy) {
    this.strategy = strategy;
  }
  //调用策略类中的算法
  public void algorithm() {
    strategy.algorithm();
  }
}

客户端调用时，代码如下：

Context context = new Context();
AbstractStrategy strategy;
strategy = new ConcreteStrategyA();
context.setStrategy(strategy);
context.algorithm();

三、demo

实现多种排序算法，并通过设置相应的策略达到相应的排序效果。

抽象策略类Strategy代码如下：

1
2
3

public interface Sort {
    int[] sort(int arr[]);
}

具体策略类ConcreteStrategy代码如下：

public class BubbleSort implements Sort{
    @Override
    public int[] sort(int[] arr) {
        int length = arr.length;
        for (int i = 0; i < length; ++i) {
            for (int j = i + 1; j < length; ++j) {
                int temp;
                if (arr[i] > arr[j]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println("冒泡排序");
        return arr;
    }
}

public class InsertionSort implements Sort {

    @Override
    public int[] sort(int[] arr) {
        int length = arr.length;
        for (int i = 1; i < length; ++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;
    }
}

public class QuickSort implements Sort{
    @Override
    public int[] sort(int[] arr) {
        System.out.println("快速排序");
        sort(arr,0,arr.length - 1);
        return arr;
    }

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

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

public class SelectionSort implements Sort{
    @Override
    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;
    }
}

Context类设计如下：

public class SortHandler {

    private Sort sort;

    public void setSort(Sort sort) {
        this.sort = sort;
    }

    public int[] sort(int arr[]) {
        sort.sort(arr);
        return arr;
    }
}

客户端调用代码如下：

public static void main(String args[]) {
  int arr[] = {1,4,6,2,5,3,7,10,9};
  int result[];
  SortHandler sh = new SortHandler();

  Sort sort;
  sort = new InsertionSort();

  sh.setSort(sort); //设置具体策略
  result = sh.sort(arr);

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

代码运行结果为：

四、总结

1. 优点

策略模式提供了对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。
策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族，恰当使用继承可以把公共的代码移到抽象策略类中，从而避免重复的代码。
策略模式提供了一种可以替换继承关系的办法。如果不使用策略模式，那么使用算法的环境类就可能会有一些子类，每一个子类提供一种不同的算法。但是，这样一来算法的使用就和算法本身混在一起，不符合“单一职责原则”，决定使用哪一种算法的逻辑和该算法本身混合在一起，从而不可能再独立演化；而且使用继承无法实现算法或行为在程序运行时的动态切换。
使用策略模式可以避免多重条件选择语句。多重条件选择语句不易维护，它把采取哪一种算法或行为的逻辑与算法或行为本身的实现逻辑混合在一起，将它们全部硬编码(Hard Coding)在一个庞大的多重条件选择语句中，比直接继承环境类的办法还要原始和落后。
策略模式提供了一种算法的复用机制，由于将算法单独提取出来封装在策略类中，因此不同的环境类可以方便地复用这些策略类。

2. 缺点

客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。
策略模式将造成系统产生很多具体策略类，任何细小的变化都将导致系统要增加一个新的具体策略类。
无法同时在客户端使用多个策略类，也就是说，在使用策略模式时，客户端每次只能使用一个策略类，不支持使用一个策略类完成部分功能后再使用另一个策略类来完成剩余功能的情况。

3. 适用场景

一个系统需要动态地在几种算法中选择一种，那么可以将这些算法封装到一个个的具体算法类中，而这些具体算法类都是一个抽象算法类的子类。换言之，这些具体算法类均有统一的接口，根据“里氏代换原则”和面向对象的多态性，客户端可以选择使用任何一个具体算法类，并只需要维持一个数据类型是抽象算法类的对象。
一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重条件选择语句来实现。此时，使用策略模式，把这些行为转移到相应的具体策略类里面，就可以避免使用难以维护的多重条件选择语句。
不希望客户端知道复杂的、与算法相关的数据结构，在具体策略类中封装算法与相关的数据结构，可以提高算法的保密性与安全性。