目标

在软件工程中一个众所周知的问题就是，不管你做什么，用户的需求肯定会变。比如一位农民第一天可能有一个想要查找库存中所有绿色苹果的功能，但第二天可能又想要找出重量大于 150 克的水果，可能过几天又会变成既要绿色苹果重量又要大于 150 克。我们该如何应对不断变化的需求？我们最理想的状态为：工作量降到最少，新添加的功能实现起来非常简单而且易于长期维护。

行为参数化是什么

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

下面我们结合上面提到的农民的例子来应对不断变化的需求。

筛选绿苹果

public static List<Apple> filterGreenApples(List<Apple> inventory){
    List<Apple> result=new ArrayList<>();
    for (Apple apple : inventory) {
        if("green".equals(apple.getColor())){
            result.add(apple);
        }
    }
    return result;
}

筛选出绿色苹果很简单吧，但是农民如果要筛选红色苹果呢？最简单的解决方法就是复制这个方法，把名字改成 filterRedApples，然后改一下 if 条件来匹配红苹果。然而如果颜色更多呢？我们不可能写一大溜的方法来匹配不同的颜色吧！一个良好的原则是在编写类似的代码后尝试将其抽象化。

把颜色作为参数

一种做法是给方法加一个参数，把颜色变成参数，这样就能灵活地适应变化了：

public static List<Apple> filterApplesByColor(List<Apple> inventory,String color){
    List<Apple> result=new ArrayList<>();
    for (Apple apple : inventory) {
        if(apple.getColor().equals(color)){
            result.add(apple);
        }
    }
    return result;
}

只要像下面这样调用就可以了：

    List<Apple> greenApples=filterApplesByColor(inventory,"green");
    List<Apple> redApples=filterApplesByColor(inventory,"red");

太简单了吧？那如果农民想要区分轻的苹果和重的苹果呢？

对你能想到的每个属性做筛选

我们写一个颜色和重量结合的方法，再加上一个 flag 来区分想要筛选哪个属性。

public static List<Apple> filterApples(List<Apple> inventory, String color, int weight, boolean flag) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
        if ((flag && apple.getColor().equals(color)) || (flag && apple.getWeight() > weight)) {
            result.add(apple);
        }
    }
    return result;
}

调用：

    List<Apple> greenApples = filterApples(inventory, "green",150,true);
    List<Apple> redApples = filterApples(inventory, "red",120,false);

上面的方法好像依然很轻松的解决了农民朋友的问题，但是客户端代码看起来糟透了，true 和 false 又是什么意思？此外解决方案还是不能很好的应对变化的需求。如果这位农民要求你对苹果的不同属性做筛选，比如大小、形状、产地等，又怎么办？而且农民要求你组合属性，做更复杂的查询，又该怎么办？你会有好多重复的 filter 方法，或一个巨大的非常复杂的方法。我们下一节就开始利用行为参数化来实现更加灵活的方法。

行为参数化

首先我们后退一步来进行更高层次的抽象：我们考虑的是苹果，需要根据 Apple 的一些属性（比如它是绿色的吗？重量超过 150 克吗？）来返回一个 boolean 值。我们把它称为谓词（即一个返回 boolean 值的函数）。让我们定义一个接口来对选择标准建模：

public interface ApplePredicate {
    boolean test (Apple apple);
}

现在我们可以使用 ApplePredicate 的多个实现代表不同的选择标准了：

筛选重量大于 150 的苹果：

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

筛选绿色苹果：

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

我们这样做已经非常类似“策略设计模式”了，在这里算法族就是 ApplePredicate，不同的策略就是 AppleHeavyWeightPredicate 或者 AppleGreenColorPredicate。

在我们的例子中根据抽象条件筛选：

public static List<Apple> filterApples(List<Apple> inventory,ApplePredicate p){
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
        if(p.test(apple)){
            result.add(apple);
        }
    }
    return result;
}

现在我们的代码已经灵活多了，读起来用起来都更容易！如果你要筛选红色并且重量大于 200 克的苹果只需要再写一个策略：

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

使用匿名类加上 Lambda 表达式：

使用匿名内部类：

我们上面所做的，依然有很多不足，我们需要声明很多只要实例化一次的类，费那么大的劲真的没必要，我们可以做的更好吗？Java 中有匿名内部类，我们利用它进一步改善代码：

    List<Apple> greenApples = filterApples(inventory, new ApplePredicate() {
        @Override
        public boolean test(Apple apple) {
            return "green".equals(apple.getColor());
        }
    });

使用 Lambda表达式

匿名内部类还是不够好，它比较笨重，占用了很多的空间。而且内部类一般比较难读。在 Java8 中新添加了 Lambda 表达式，我们如果利用了它只需要一句话就解决了问题：

    List<Apple> greenApples = filterApples(inventory, (Apple apple)->"green".equals(apple.getColor()));

将 List 类型抽象化

通往抽象的路上，我们还可以更进一步。目前我们还只适用于 Apple,我们还可以将 List 类型抽象化，从而超越眼前所要处理的问题：

public interface Predicate<T>{
    boolean test(T t);
}

修改filter方法：

public static <T> List<T> filter(List<T> list,Predicate<T> p){
    List<T> result = new ArrayList<>();
    for (T e : list) {
        if(p.test(e)){
            result.add(e);
        }
    }
    return result;
}

现在我们可以把filter方法用在香蕉、桔子、 Integer 或者是 String 上了，比如说我们要找出一个数字集合中的所有偶数，同样只需要一句话：

    List<Integer> evenNumbers=filter(numbers,(i)->i%2==0);

Lambda 表达式巩固练习

用 Comparator 升序排序

    //对苹果重量进行排序
    List<Apple> inventory = new ArrayList<>();
    inventory.add(new Apple("green", 155));
    inventory.add(new Apple("green", 177));
    inventory.add(new Apple("green", 244));
    inventory.add(new Apple("red", 123));

    //原始方法
    //Collections.sort(inventory, new Comparator<Apple>() {
    //    @Override
    //    public int compare(Apple a1, Apple a2) {
    //        return a1.getWeight() > a2.getWeight() ? -1 : a1.getWeight() < a2.getWeight() ? 1 : 0;
    //    }
    //});

    //使用 Lambda 表达式
    Collections.sort(inventory, (a1, a2) -> a1.getWeight() > a2.getWeight() ? 1 : a1.getWeight() < a2.getWeight() ? -1 : 0);
    for (Apple apple : inventory) {
        System.out.println(apple.getWeight());
    }

Thread 的使用

new Thread(()->System.out.println("Hello world")).start();

Android 中 Lambda 的简单使用

提前准备：

defaultConfig {
    ...
    jackOptions {
        enabled true
    }
}

compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
}

点击事件调用：

    findViewById(R.id.btn).setOnClickListener((v) -> Toast.makeText(this, "hello", Toast.LENGTH_SHORT).show());

参考

本文纯属《Java8 实战》学习笔记