策略 （Stragety）

定义：定义算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

场景：当不同的行为堆砌在一个类中，难以避免使用条件语句选择行为时，将这些行为封装在独立的策略类中，可以消除条件语句；一个系统需要动态地选择一种算法时。

类型：行为型

相比之前提到的设计模式，策略的使用更加广泛，它简单直观，作用强大，只要业务中存在同一场景会有不同的处理规则，就可以用到策略。
在Java类库中使用最频繁的策略当属Comparator。

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

Comparator的角色是抽象策略（abstract stragety），而实现了Comparator的具体排序规则就是具体策略（concrete strategy）。

在JDK 1.8的Comparator中还实现了诸多缺省方法，例如翻转排序、空值优先、排序规则链等，这里使用了模版方法的思想。

在客户端代码中实现好比较算法，剩下的排序工作，交给类库去做即可。

Collections.sort(studentList, new Comparator<Student>() {
            @Override
            public int compare(Student a, Student b) {
                return a.getScore()-b.getScore();
            }
        });

当然在实际生产中使用更简便易读的comparing方法，岂不美哉？

Collections.sort(studentList,Comparator.comparing(Student::getScore));

除了Comparator，还有一个典型案例：线程池的饱和策略。以下是带有指定饱和策略的线程池构造方法（最后一个入参RejectedExecutionHandler handler就是指定饱和策略）

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

饱和策略将在有界队列被填满后触发，我们无需关心策略的具体调用，只需专注于如何设计策略使得线程池更加健壮。以下是ThreadPoolExecutor提供的四种预设策略中的抛弃最旧策略：

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardOldestPolicy} for the given executor.
         */
        public DiscardOldestPolicy() { }

        /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }

public interface Observer {
    void update(Observable o, Object arg);
}

public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;

    public Observable() {
        obs = new Vector<>();
    }

    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    public void notifyObservers(Object arg) {
        /*
         * a temporary array buffer, used as a snapshot of the state of
         * current Observers.
         */
        Object[] arrLocal;

        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }
    
    ...省略其它方法
}

        List<Integer> trueList = Collections.emptyList();

        //创建一个代理类，实现特定接口，并将调用分发到指定的调用处理器上
        List proxyList = (List) Proxy.newProxyInstance(List.class.getClassLoader(),
                new Class[]{List.class}, (proxy, method, args) -> {
                    System.out.println("enter invoke handler");
                    return method.invoke(trueList,args);
                });
        System.out.println(proxyList.size());
        

输出
----------------
enter invoke handler
0