行为类模式--策略模式

一  定义，类型及类图 

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

策略模式是对算法的封装，把一系列的算法分别封装到对应的类中，并且这些类实现相同的接口，相互之间可以替换。在前面说过的行为类模式中，有一种模式也是关注对算法的封装——模版方法模式，对照类图可以看到，策略模式与模版方法模式的区别仅仅是多了一个单独的封装类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. 策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不用的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

五 适用常见

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

1.几个类的主要逻辑相同，在部分逻辑的算法和行为上稍有区别的情况.                                                                                            2.有几个类似的行为，或者说算法，科幻段需要动态地决定使用哪一个，那么使用策略模式，将这些算法封装给客户端调用。

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

六、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

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

具体策略类 SortComparator

public class SortComparator implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        Student student1 = (Student) o1;
        Student student2 = (Student) o2;
        return student1.getAge() - student2.getAge();
    }
}

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