一、定义、类型及类图

• 定义：定义一组算法，将每个算法都封装起来，并且使他们之间可以互换。（策略模式定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户——出自《大话设计模式》）
• 类型：行为类模式
• 类图

策略模式是对算法的封装，把一系列的算法分别封装到对应的类中，并且这些类实现相同的接口，相互之间可以替换。在前面说过的行为类模式中，有一种模式也是关注对算法的封装——模版方法模式，对照类图可以看到，策略模式与模版方法模式的区别仅仅是多了一个单独的封装类Context，它与模版方法模式的区别在于：在模版方法模式中，调用算法的主体在抽象的父类中，而在策略模式中，调用算法的主体则是封装到了封装类Context中，抽象策略Strategy一般是一个接口，目的只是为了定义规范，里面一般不包含逻辑。其实，这只是通用实现，而在实际编程中，因为各个具体策略实现类之间难免存在一些相同的逻辑，为了避免重复的代码，我们常常使用抽象类来担任Strategy的角色，在里面封装公共的代码，因此，在很多应用的场景中，在策略模式中一般会看到模版方法模式的影子。

二、策略模式的结构

• 环境(Context)角色：持有一个Strategy的引用，也叫上下文，对策略进行二次封装，目的是避免高层模块对策略的直接调用。
• 抽象策略(Strategy)：通常情况下为一个接口，当各个实现类中存在着重复的逻辑时，则使用抽象类来封装这部分公共的代码，此时，策略模式看上去更像是模版方法模式。
• 具体策略(ConcreteStrategy)：具体策略角色通常由一组封装了算法的类来担任，这些类之间可以根据需要自由替换。

三、策略模式代码实现

interface IStrategy {public void doSomething();
}
class ConcreteStrategy1 implements IStrategy {public void doSomething() {System.out.println("具体策略1");}
}
class ConcreteStrategy2 implements IStrategy {public void doSomething() {System.out.println("具体策略2");}
}
class Context {private IStrategy strategy;public Context(IStrategy strategy){this.strategy = strategy;}public void execute(){strategy.doSomething();}
}public class Client {public static void main(String[] args){Context context;System.out.println("-----执行策略1-----");context = new Context(new ConcreteStrategy1());context.execute();System.out.println("-----执行策略2-----");context = new Context(new ConcreteStrategy2());context.execute();}
}

四、策略模式的优缺点

• 主要优点：
  1. 策略类之间可以自由切换，由于策略类实现自同一个抽象，所以他们之间可以自由切换。
  2. 易于扩展，增加一个新的策略对策略模式来说非常容易，基本上可以在不改变原有代码的基础上进行扩展。
  3. 避免使用多重条件，如果不使用策略模式，对于所有的算法，必须使用条件语句进行连接，通过条件判断来决定使用哪一种算法，在上一篇文章中我们已经提到，使用多重条件判断是非常不容易维护的。
• 主要缺点：
  1. 维护各个策略类会给开发带来额外开销，可能大家在这方面都有经验：一般来说，策略类的数量超过5个，就比较令人头疼了。
  2. 必须对客户端（调用者）暴露所有的策略类，因为使用哪种策略是由客户端来决定的，因此，客户端应该知道有什么策略，并且了解各种策略之间的区别，否则，后果很严重。例如，有一个排序算法的策略模式，提供了快速排序、冒泡排序、选择排序这三种算法，客户端在使用这些算法之前，是不是先要明白这三种算法的适用情况？再比如，客户端要使用一个容器，有链表实现的，也有数组实现的，客户端是不是也要明白链表和数组有什么区别？就这一点来说是有悖于迪米特法则的。
• 优点补充（出自——大话设计模式）：
  1. 策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
  2. 策略模式的Strategy实现层为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。
  3. 简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
  4. 当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的ConcreteStrategy类中，可以在使用这些行为的类中消除条件语句。
  5. 策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不用的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

五、适用常见

做面向对象设计的，对策略模式一定很熟悉，因为它实质上就是面向对象中的继承和多态，在看完策略模式的通用代码后，我想，即使之前从来没有听说过策略模式，在开发过程中也一定使用过它吧？至少在在以下两种情况下，大家可以考虑使用策略模式，

• 几个类的主要逻辑相同，只在部分逻辑的算法和行为上稍有区别的情况。
• 有几种相似的行为，或者说算法，客户端需要动态地决定使用哪一种，那么可以使用策略模式，将这些算法封装起来供客户端调用。

策略模式是一种简单常用的模式，我们在进行开发的时候，会经常有意无意地使用它，一般来说，策略模式不会单独使用，跟模版方法模式、工厂模式等混合使用的情况比较多。

六、JDK的策略模式应用

1、ThreadPoolExecutor(线程池)中的RejectedExecutionHandler

学习ThreadPoolExecutor(线程池)就肯定要知道它的构造方法每个参数的意义：

    /*** Handler called when saturated or shutdown in execute.*/private volatile RejectedExecutionHandler handler;    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {        //....this.handler = handler;}    /*** Invokes the rejected execution handler for the given command.* Package-protected for use by ScheduledThreadPoolExecutor.*/final void reject(Runnable command) {handler.rejectedExecution(command, this);}

其中我们可以找到RejectedExecutionHandler，这个参数代表的是拒绝策略(有四种具体的实现：直接抛出异常、使用调用者的线程来处理、直接丢掉这个任务、丢掉最老的任务)

其实这就是策略模式的体现了。

2 Java 对象排序中的应用

Comparator 外部比较器接口 我们如果需要控制某个类的次序，而该类本身不支持排序（即没有实现Comparable接口）；那么可以建立一个该类的比较器来排序，这个比较器只需要实现Comparator接口即可。,通过实现Comparator类来新建一个比较器，然后通过该比较器来对类进行排序。Comparator 接口其实就是一种策略模式的实践 事例代码： 抽象策略类 Comparator

public interface Comparator<T> {int compare(T o1, T o2);boolean equals(Object obj);}

具体策略类 SortComparator

public class SortComparator implements Comparator {@Overridepublic int compare(Object o1, Object o2) {Student student1 = (Student) o1;Student student2 = (Student) o2;return student1.getAge() - student2.getAge();}
}

策略模式上下文 Collections

public class Client {public static void main(String[] args) {Student stu[] = {new Student("张三" ,23),new Student("李四" ,26), new Student("王五" ,22)};Arrays. sort(stu,new SortComparator());System.out.println(Arrays.toString(stu));List<Student> list = new ArrayList<>(3);list.add( new Student("zhangsan" ,31));list.add( new Student("lisi" ,30));list.add( new Student("wangwu" ,35));Collections. sort(list,new SortComparator());System.out.println(list);}}

数据流

countRunAndMakeAscending:355, TimSort (java.util)
sort:220, TimSort (java.util)
sort:1438, Arrays (java.util)
main:20, Client (designpattern.strategy.compare)

调用Collections.sort方法之后走的是Arrays.sort()方法，然后TimSort类中countRunAndMakeAscending方法中调用具体比较器的算法实现进行比较，完成排序。这是大家比较常用的对象排序工具类。