Java设计模式----策略模式

策略的选择很多时候再开发过程中都会涉及到，比如说排序，有时候需要使用从大到小排序的方案，有时候需要从小到大的排序方案。与其直接在使用时实现排序算法，不如将算法封装起来，这样的话，就可以在程序运行时根据不同场景动态地选择合适的算法了。运行时动态选择方案可以使代码更灵活、复用性高、易于扩展等，策略模式就是本文中介绍的非常有用的可以达成这些好处的设计模式。

---

1.策略模式

策略模式(Strategy Pattern)，定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化，也称为政策模式(Policy Pattern)。 

策略模式的结构图如下：

Context代表这Strategy的接口，由它的algorithm()方法来实际执行某个Strategy的algorithm()。我将以一个例子来说明策略模式的用法。

---

2.代码实现

2.1  一般用法

假设生产的某品牌汽车，对于换挡方式可以切换：手动换挡，自动挡。

 定义换挡接口Transission，和其两个实现类：ManualTrans(手动档）, AutomaticTrans（自动档），shift（）方法执行换挡

interface Transmission {
    void shift(String level);
}

class ManualTrans implements Transmission {

    @Override
    public void shift(String level) {
        System.out.printf("手动档切换至【%s】档
", level);
    }
}

class AutomaticTrans implements Transmission {

    @Override
    public void shift(String level) {
        System.out.printf("自动档切换至【%s】档
", level);
    }
}

定义汽车Car类，Car类也充当上下文，apply()方法接收换挡策略和要换的档

class Car {
    public void apply(Transmission trans, String level) {
        trans.shift(level);
    }
}

客户端调用， 第一次采用手动换挡策略到“R”档， 第二次采用自动档到了“D”档

public class StrategyDemo1 {
    public static void main(String[] args) {
        //汽车
        Car car = new Car();

        //手动换到"R"档
        Transmission trans = new ManualTrans();
        car.apply(trans, "R");

        //自动换到"D"档
        trans = new AutomaticTrans();
        car.apply(trans, "D");

    }
}

输出结果：

手动档切换至【R】档
自动档切换至【D】档

2.2 函数式编程

Java8之前，没有引入Lambda表达式，经常会传一个对象给某接口，这个对象封装了某个算法，这类对象就是Java中的闭包(Closure)，可以用作回调。比如常用的排序：

public class StrategyDemo2 {
    public static void main(String[] args) {
        //创建一个整数列表
        List<Integer> numbers = new ArrayList<>();
        numbers.addAll(Arrays.<Integer>asList(12, 23, 35, 1, 6, 231, 67));

        //从小到大排序
        Collections.sort(numbers, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });

        System.out.println(numbers);
    }
}

注意到，Colections.sort()方法中，我们传入了实现Comparator接口的匿名内部类的实例，这就是Java中常见的闭包形式， 一般把只有一个方法的interface称为function types，即函数类型，其实例叫做function objects，即函数对象。在这里，Comparator接口代表了策略接口，匿名内部类对象则代表了一个具体的排序策略。

Java8中，Lambda表达式的引入，使Java中函数式编程得以实现，上面的例子，用函数式编程看起来则更为直观和简洁：

public class StrategyDemo3 {
    public static void main(String[] args) {
        //创建一个整数列表
        List<Integer> numbers = new ArrayList<>();
        numbers.addAll(Arrays.<Integer>asList(12, 23, 35, 1, 6, 231, 67));

        //从小到大排序
        Collections.sort(numbers, (num1, num2) -> num1.compareTo(num2));

        System.out.println(numbers);
    }
}

 函数对象被当作参数传入方法，被当作某一策略使用。

---

3.总结

通过两个例子展示了策略模式应用的场景，从我个人的体会当中，策略模式的本质就是将一个封装有算法的对象A，传递给对象B，B回调A的算法。策略模式是开放-封闭原则和聚合/合成复用原则的极佳体现，比如对于上文的排序，可以很容易地改为从大到小排序，只需要把传入的函数对象改一个即可，不需要修改原来的代码，实际上正式因为具备良好的扩展性，所以匿名内部类与策略模式才是如此地天作之合。

对于汽车换挡的例子，假如用继承方式，分别派生两个子类 ManualTransCar和AutomicTransCar， 即一个手动挡的车和一个自动档的车，显然就是很不灵活了，策略模式就体现了聚合/合成服用原则，换挡策略可以方便地切换，代码几乎都不需要改动。