《Java8实战》-读书笔记第二章

经过行为参数化传递代码

行为参数化

在《Java8实战》第二章主要介绍的是经过行为参数化传递代码，那么就来了解一下什么是行为参数化吧。

在软件工程中，一个从所周知的问题就是，无论你作什么，用户的需求老是会变的（PM的需求老是会变的）。比方说，有个应用程序是帮助农民了解本身的库存。这位农民可能想有一个查找库存中全部绿色苹果的功能。可是到了次日，他忽然告诉你：“其实我还想找出全部重量超过150克的苹果。”，你一想简单嘛不就是改一下条件而已。因而过了两天，他又说：“要是我能够筛选即便绿色的苹果，重量也超过150克的苹果。”，这样频繁的改需求也不太好，面对这样的状况理想状态下应该把工做量降到最低。此外，相似的功能实现起来应该仍是很简单，并且利于长期维护。

行为参数化就是要帮助你处理频繁更变的需求的一种软件开发模式。一言以蔽之，它意味着拿出一个代码块，把它准备好却不去执行它。这个代码块之后能够被你程序的其余部分调用，这意味着你能够推迟这块代码的执行。例如，你能够将代码块做为参数传递给另一个方法，稍后再去执行它。这样，这个方法的行为就基于那块代码被参数化了。

应对不断变化的需求

想要编写能应对变化的需求并不容易。让咱们来看一个例子，咱们将会逐渐的改进这个例子，以展现一些让代码更灵活的作法。就像农场库存程序而言，你须要实现一个从列表中筛选绿苹果的功能。

筛选苹果

1. 筛选绿苹果，可能你选择最初的解决方案就是这样：

private static List<Apple> filterGreenApples(List<Apple> apples) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        if ("green".equals(apple.getColor())) {
            appleList.add(apple);
        }
    }
    return appleList;
}
复制代码

如今代码中就是筛选绿苹果。但如今农民改主意了，他还想要筛选红苹果。按照最简单的方法就是，把方法复制一下而且改一下条件为筛选红苹果的条件。是的，这样作起来很简单，要是农民想要筛选多种颜色：青色、深红、淡红...这种方法就不太适合了。

2. 优化代码，经过颜色做为参数筛选苹果：

private static List<Apple> filterApplesByColor(List<Apple> apples, String color) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        if (color.equals(apple.getColor())) {
            appleList.add(apple);
        }
    }
    return appleList;
}
复制代码

很简单对吧。如今，农民又有想法：“能筛选出轻苹果和重苹果就好啦！通常重苹果的重量是150克。”你可能早就想到了须要经过重量来筛选苹果，因而你又把参数穿进来做为条件进行筛选。

3. 将重量做为参数，进行重苹果筛选：

private static List<Apple> filterApplesByWeight(List<Apple> apples, int weight) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        if (apple.getWeight() > weight) {
            appleList.add(apple);
        }
    }
    return appleList;
}
复制代码

是的，解决方法很简单，可是你复制了大部分的代码来实现遍历库存，并对每一个苹果应用筛选条件。这样破坏了DRY(Don't Repeat Yourself 不要重复本身)的软件工程原则。或许，你一下就想到了这办法，将全部的参数都放在一个方法中，这样就能够简化不少代码了。

4. 第三次尝试，对你能想到的每一个属性作筛选：

private static List<Apple> filterApples(List<Apple> apples, String color, int weight, boolean flag) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        boolean result = (flag && apple.getWeight() > weight) || (!flag && color.equals(apple.getColor()));
        if (result) {
            appleList.add(apple);
        }
    }
    return appleList;
}
复制代码

代码看起来很简单，可是感受倒是不太好。若是不把注释写清楚，别人阅读你代码时根本就不知道flag是干吗用的。要是，农民忽然又有个想法，需用经过大小、形状、产地等条件来进行筛选怎么办？因此，咱们须要利用行为参数化来解决这个问题，提升代码的灵活性。

行为参数化

目前，你须要一种比添加不少参数更好的方法来应对变化的需求。让咱们退一步来看看更高层次的抽象。一种可能解决方案是对你的悬着标准建模：你考虑的是苹果，须要根据Apple的某些属性（好比它是绿色的吗？重量超过150克吗？）来返回一个boolean值。是的，你可能已经想到了第一章中介绍到了的谓词。

根据谓词进行筛选

首先，咱们应该定义一个接口来对选择标准建模：

public interface ApplePredicate {
    /**
     * 根据给定的参数计算此谓词。
     *
     * @param apple
     * @return
     */
    boolean test(Apple apple);
}
复制代码

能够用ApplePredicate的实现类来表明不一样的选择标准：

只筛选绿苹果

public class AppleGreenColorPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return "green".equals(apple.getColor());
    }
}
复制代码

只筛选重苹果

public class AppleHeavyWeightPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return apple.getWeight() > 150;
    }
}
复制代码

你能够把这些标准看做filter的不一样行为。这就像策略设计模式同样，它让你定义一组方法，把它们封装起来，而后在运行时选择一个方法。这里，方法就是ApplePredicate，不一样的策略就是AppleHeavyWeightPredicate和AppleGreenColorPredicate。

你能够将filterApples方法接受一个ApplePredicate对象，对Apple作条件测试。这样就是行为参数化：让方法接受多种行为做为参数，并在内部使用，来完成不一样的行为。

根据抽象条件筛选

private static List<Apple> filterApples(List<Apple> apples, ApplePredicate<Apple> applePredicate) {
    List<Apple> appleList = new ArrayList<>();
    for (Apple apple : apples) {
        if (applePredicate.test(apple)) {
            appleList.add(apple);
        }
    }
    return appleList;
}
复制代码

代码的传递/行为

酷，这段代码看起来不少了，读起来、用起来也更容易！如今你能够建立不一样的ApplePredicate对象，并将它们传递给filterApples方法。这样就能够根据不一样的条件来建立一个类而且实现ApplePredicate就能够了。

如今，农民要求须要筛选红苹果。那么，咱们就能够根据条件建立一个类而且实现ApplePredicate：

public class AppleRedAndHeavyPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return "red".equals(apple.getColor()) && apple.getWeight() > 150;
    }
}
复制代码

List<Apple> filterApples2 = filterApples(apples, new AppleRedAndHeavyPredicate());
System.out.println("经过谓词筛选红苹果而且是重苹果:" + filterApples2);
复制代码

酷，如今filterApples方法的行为已经取决于经过ApplePredicate对象来实现了。这就是行为参数化了！

可是，你有没有发现，咱们每次新增一个条件就须要新增一个类。这样作有点太过于麻烦，或许咱们能够经过Lambda，将表达式传递给filterApples方法，这样就无需定义多个ApplePredicate类，从而去掉没必要要的代码，并减轻工做量。

多种行为，一个参数

行为参数化的好处在与你能够把迭代要筛选的集合的逻辑与对集合中每一个元素应用的行为区分开来。这样你就能够重复使用同一个方法，给它不一样的行为来达到不一样的目的。

为了可以对参数化行为运用自如，而且简化代码，咱们来尝试将参数经过Lambda的方式传递给filterApples。

经过Lambda的方式来筛选红苹果:

List<Apple> filterApples3 = filterApples(apples, apple -> "red".equals(apple.getColor()));
复制代码

经过Lambda的方式来筛选红苹果而且是重苹果：

List<Apple> filterApples4 = filterApples(apples, apple -> "red".equals(apple.getColor()) && apple.getWeight() > 150);
复制代码

是的，使用的已经仍是原来的条件，而且再也不须要根据不一样的条件再去实现一个ApplePredicate类了，这样极大的简化了代码。可是，农民又有一个需求了：“如今，不仅是须要对苹果进行筛选了，还须要对香蕉、橘子、草莓进行筛选了。”

可是，咱们目前的代码只可以对苹果进行筛选而已，为了解决这个问题，咱们能够将类型定义为泛型，这样就不仅是只能对苹果进行筛选了。

使用谓词

其实，咱们能够不须要去定义谓词，由于在Java中就一个了Predicate了，咱们可使用它而且实现咱们的功能。

定义一个泛型的filter方法：

private static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.test(t)) {
            result.add(t);
        }
    }
    return result;
}
复制代码

这个方法是一个通用的筛选方法，不仅是能够用于筛选苹果。

筛选重苹果:

List<Apple> heavyApples = filter(apples, (Apple apple) -> apple.getWeight() > 150);
复制代码

筛选能被2整除的数：

List<Integer> numbers = Arrays.asList(10, 11, 8, 5, 1, 2, 29, 18);
List<Integer> integerList = filter(numbers, number -> number % 2 == 0);
复制代码

是否是很酷？如今的代码简洁性和灵活性都很高，在Java8以前这些都是不可能作到的！

如今，你已经感受到了行为参数化是一个颇有用的模式，它可以轻松地适应不断变化的需求。在Java中不少方法均可以用不一样的行为来参数化，好比使用Comparator排序，用Runnable执行一个代码块等等。

使用Comparator来排序：

apples.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));
复制代码

或者这样：

apples.sort(Comparator.comparing(Apple::getWeight));
复制代码

使用Runnable执行某个代码块：

Thread t = new Thread(() -> System.out.println("HelloWorld"));
复制代码

总结

1. 行为参数化，就是一个方法接受多个不一样的行为做为参数，并在内部使用它们，完成不一样行为的能力。
2. 行为参数化可让代码更好的适应不断变化的要求，减轻工做量。
3. 传递代码，就是将新行为做为参数传递给方法。但在Java8以前这实现起来很啰嗦。为接口生命许多只是用一次的实体类而形成的啰嗦代码，在Java8以前采用匿名类来减小。
4. JavaAPI包含了不少能够用不一样行为进行参数化的方法，包括排序、线程等。

代码示例：

Github：chap2

公众号