一、概念以及背景
策略模式(Strategy Pattern):定义一系列算法类，将每一个算法封装起来，并让它们可以相互替换，策略模式让算法独立于使用它的客户端而变化，也称为政策模式(Policy)。
简而言之，策略模式是客户端在运行时选择某种解决方案（策略，方法，算法）来解决问题，而解决方案（策略，方法，算法）的定义与使用是分开的，即解决方案与客户端的调用中间有个类可以针对不同的问题，采取不同的解决方案，该中间类中持有一个对策略类接口的引用实例，用于定义所采用的策略。
本文涉及的代码在github上，点击 链接 可查看源码。
文章会用两种方式来实现策略模式，一种是Java8之前通过自己写接口的方式实现策略模式，另一种是采用Java8提供的函数式接口来实现策略模式，也用了lambda表达式，使代码看起来更加简洁，使我们能更专注于业务逻辑的处理。
文章所用的场景是这样的：根据快递包裹的重量计算快递公司的邮费，不同的快递公司有不同的邮费计算方式，如京东，申通，圆通等快递公司的邮费计算都是不一样的。
二、策略模式
策略模式需要一个策略接口，定义一个待实现的方法，不同的解决方案（方法）实现该策略接口，以实现不同的解决方法，接着为了让客户端和策略解耦，即解决方案的定义与使用是分开的，我们需要有一个中间类，我们先看一下上面提到的场景下的UML类图：
CalculateStrategy是策略接口，有一个待实现的calculate方法，计算邮费，根据传入的包裹重量，返回计算好的邮费。JdCalculateStrategy、StoCalculateStrategy、YtoCalculateStrategy分别为京东、申通、圆通不同的计算邮费方式，实现了CalculateStrategy接口的calculate方法。
CalculateStrategy策略接口代码如下：
public interface CalculateStrategy {
Double calculate(Integer weight);
}
JdCalculateStrategy类：
public class JdCalculateStrategy implements CalculateStrategy {
@Override
public Double calculate(Integer weight) {
return 10 + weight * 1.2;
}
}
StoCalculateStrategy类：
public class StoCalculateStrategy implements CalculateStrategy {
@Override
public Double calculate(Integer weight) {
return 12 + weight * 0.8;
}
}
YtoCalculateStrategy类：
public class YtoCalculateStrategy implements CalculateStrategy {
@Override
public Double calculate(Integer weight) {
return 8 + weight * 1.5;
}
}
我们可以看到不同的快递公司有不同的策略来计算邮费。为了避免在往后邮费计算需要修改的时候，也需要修改客户调用方代码，也为了进一步解耦，我们需要有一个中间类，来把策略封装起来，持有策略接口。
中间类CalculateContext代码如下：
public class CalculateContext {
//持有策略接口
private CalculateStrategy calculateStrategy;
public void setCalculateStrategy(CalculateStrategy calculateStrategy) {
this.calculateStrategy = calculateStrategy;
}
public Double calculate(Integer weigth) {
return calculateStrategy.calculate(weigth);
}
}
在运行时选择某种解决方案，客户端代码如下：
public class Client {
public static void main(String[] args) {
Integer weight = 15;
CalculateContext context = new CalculateContext();
CalculateStrategy calculateStrategy = new JdCalculateStrategy();
context.setCalculateStrategy(calculateStrategy);
System.out.println("运行时指定策略，计算邮费如下：" + context.calculate(weight));
}
}
三、lambda重构策略模式
仔细思考，不难发现，不同的策略其实是不同的方法，那么有没有一种办法，在运行时要选择某种方法，我们可以直接提供方法呢？当然不是if else 不同分支里面调用我们写好的不同方法啦，这样的话代码结构比较乱，高度耦合了，分支也比较多，这里采用的是Java8提供的一个内置函数式接口：
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
该接口的用法，我们可以看apply方法，入参是T泛型类，返回值是R泛型类，仔细想想是不是符合我们的要求，计算邮费的方法：入参是Integer类型的包裹重量，返回参数是Double型的邮费，这里我们就可以这样用该接口，Function<Integer, Double>，计算邮费的方法用lambda表达式去实现apply接口方法。光是这样还是不行的，因为我们要怎么根据快递公司来方便地调用lambda表达式呢？答案是：用Map集合，key是快递公司，value是函数式接口的lambda表达式即可。
快递公司枚举类，作为map的key：
public enum ParcelCompanyEnum {
ZTO("中通快递"),YTO("圆通快递"),STO("申通快递"),JD("京东快递");
String name;
ParcelCompanyEnum(String name) {
this.name = name;
}
}
CalculatePostage类有一个Map成员变量，在类对象初始化的时候初始化该map，map设置lambda表达式，实现函数式接口，
public class CalculatePostage {
Map<ParcelCompanyEnum, Function<Integer, Double>> map = new HashMap<>(5);
{
map.put(ParcelCompanyEnum.JD, this::calculateJd);
map.put(ParcelCompanyEnum.STO, this::calculatSto);
map.put(ParcelCompanyEnum.YTO, this::calculateYto);
map.put(ParcelCompanyEnum.ZTO, this::calculateZto);
}
public Double calculateJd(Integer weight) {
return 10 + weight * 1.2;
}
public Double calculatSto(Integer weight) {
return 12 + weight * 0.8;
}
public Double calculateYto(Integer weight) {
return 8 + weight * 1.5;
}
public Double calculateZto(Integer weight) {
return 9 + weight * 1.1;
}
}
接着，在客户端是这样子来调用的：
public class Client {
public static void main(String[] args) {
ParcelCompanyEnum company = ParcelCompanyEnum.JD;
Integer weight = 15;
CalculatePostage calculatePostage = new CalculatePostage();
System.out.println("Java8 lambda + 策略模式 计算邮费：" + calculatePostage.map.get(company).apply(weight));
}
}
先根据快递公司来获取不同的策略，然后传入包裹重量，最后返回计算结果。
如果你对函数式接口、lambda表达式不熟悉或者不了解的话，我推荐《Java8实战》这本书，可以留个邮箱我发电子书。
三、拓展Java8提供的内置函数式接口
