Java行为参数化：从啰嗦到简洁的代码进化_今天还要求我们按照颜色筛选苹果,明天可能就要求我们按照重量筛选-CSDN博客

1. 引言：应对变化的需求

在软件开发的世界里，变化是永恒的主题。客户的需求像六月的天气一样，说变就变。今天还要求我们按照颜色筛选苹果，明天可能就要求我们按照重量筛选，后天又可能要找出所有红色的、重量超过150克的苹果……

面对这些不断变化的需求，我们如何编写出灵活、可维护的代码呢？每次需求变更都去修改核心代码，这显然不是一个好办法。我们需要一种方法，让我们的代码能够更好地适应变化，减少未来的工作量。

这就是行为参数化发挥作用的地方。行为参数化是一种编程思想，它可以帮助我们编写出更灵活、更可复用的代码。

那么，什么是行为参数化？Java 8 又如何让行为参数化变得更简单？本文将带你一探究竟。

2. 行为参数化：概念解析

定义

简单来说，行为参数化就是一个方法接受多个不同的行为作为参数，并在内部使用它们，完成不同行为的能力。

这里的“行为”，可以理解为一段代码逻辑，或者一个函数。行为参数化的核心思想在于将“做什么”（行为）与“怎么做”（实现）分离。

核心思想

想象一下，你有一个方法，它的主要功能是遍历一个列表，并对列表中的每个元素进行处理。但是，具体的处理逻辑（也就是“行为”）可能会根据不同的需求而变化。

行为参数化允许你将这个“处理逻辑”作为参数传递给方法。这样，你就可以在不修改方法本身的情况下，通过改变传入的“行为”参数，来实现不同的处理方式。

好处

行为参数化有很多好处：

提高代码灵活性和可复用性： 同一个方法可以处理不同的行为，减少重复代码。
更好地适应需求变化： 当需求变化时，你只需要修改或添加新的“行为”参数，而不需要修改核心代码。
减少重复代码： 避免了为每个不同的行为编写单独的方法。

3. Java 8 之前的行为参数化：挑战与啰嗦

在 Java 8 之前，要实现行为参数化并不容易，往往需要编写大量的啰嗦代码。让我们通过一个例子来看看。

案例引入：筛选苹果

假设我们有一个 Apple 类：

public class Apple {
    private String color;
    private int weight;

    // 构造方法、getter 和 setter 省略
}

现在，我们需要编写一个方法来筛选苹果。一开始，需求很简单：筛选出所有绿色的苹果。

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;
}

后来，需求变了，要筛选出所有红色的苹果。我们又得添加一个方法：

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

你可能已经发现了问题：这两个方法只有一行代码不同（颜色判断），其余部分完全一样。如果需求继续变化，要筛选重量超过150克的苹果、黄色的苹果……我们岂不是要写无数个类似的方法？

策略模式的尝试

为了解决这个问题，我们可以尝试使用策略模式。我们定义一个 ApplePredicate 接口，表示一个筛选苹果的策略：

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

然后，为每个筛选条件创建一个实现类：

// 筛选绿色苹果的策略
public class AppleGreenColorPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return "green".equals(apple.getColor());
    }
}

// 筛选重量超过150克的苹果的策略
public class AppleHeavyWeightPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return apple.getWeight() > 150;
    }
}

现在，我们可以编写一个通用的 filterApples 方法，它接受一个 ApplePredicate 参数：

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;
}

使用时，我们可以这样：

List<Apple> greenApples = filterApples(inventory, new AppleGreenColorPredicate());
List<Apple> heavyApples = filterApples(inventory, new AppleHeavyWeightPredicate());

这种方式确实有所改进，将筛选逻辑封装到了不同的类中，但仍然有一个问题：我们需要编写大量的实体类，即使它们只使用一次。

匿名类的救场

为了进一步简化代码，我们可以使用匿名类：

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

这样就不用单独定义实体类了。但是，匿名类仍然比较啰嗦，代码可读性也不高。

4. Java 8 的行为参数化：Lambda 表达式的威力

Java 8 引入的 Lambda 表达式，让行为参数化变得前所未有的简单和优雅。

Lambda 表达式登场

Lambda 表达式，可以理解为一种简洁的、可传递的匿名函数。它没有名称，但有参数列表、函数主体、返回类型，甚至可以抛出异常。

Lambda 表达式的基本语法如下：

(parameters) -> expression
// 或者
(parameters) -> { statements; }

parameters: 参数列表。可以为空，或包含一个或多个参数。
->: Lambda 操作符，将参数列表和函数主体分隔开。
expression 或 { statements; }: 函数主体。可以是一个表达式，也可以是一段代码块。

Lambda 表达式的核心思想就是：用更简洁的语法来表示行为。

重构案例：Lambda 表达式的魔法

让我们回到之前的苹果筛选例子。有了 Lambda 表达式，我们可以这样重构 filterApples 方法（方法本身不需要修改，只需要改变调用方式）：

// 筛选红色苹果
List<Apple> redApples = filterApples(inventory, (Apple apple) -> "red".equals(apple.getColor()));

// 筛选重量超过150克的苹果
List<Apple> heavyApples = filterApples(inventory, (Apple apple) -> apple.getWeight() > 150);

// 筛选红色且重量超过150克的苹果
List<Apple> redAndHeavyApples = filterApples(inventory, (Apple apple) -> 
    "red".equals(apple.getColor()) && apple.getWeight() > 150
);

看看，代码是不是瞬间清爽了许多？我们不再需要定义实体类，也不需要啰嗦的匿名类，只需要一行简洁的 Lambda 表达式，就能搞定不同的筛选逻辑。

与之前的方法对比：

实体类： 需要为每个筛选条件定义一个类，代码冗余。
匿名类： 比实体类简洁，但仍然比较啰嗦，可读性不高。
Lambda 表达式： 最简洁、最易读的方式，直接将筛选逻辑作为参数传递。

Lambda 表达式的优势一目了然：简洁、灵活、易读。

方法引用（可选）

如果你的 Lambda 表达式只是简单地调用一个已有的方法，你还可以使用方法引用来进一步简化代码。

例如，假设 Apple 类有一个 isGreen 方法：

public class Apple {
    // ... 其他代码 ...

    public boolean isGreen() {
        return "green".equals(this.getColor());
    }
}

我们可以使用方法引用来筛选绿色苹果：

List<Apple> greenApples = filterApples(inventory, Apple::isGreen);

Apple::isGreen 就是一个方法引用，它指向 Apple 类的 isGreen 方法。

5. 行为参数化的应用场景

除了集合处理，行为参数化在 Java API 中还有很多应用场景：行为参数化在 Java API 中随处可见，它是许多功能的基石。以下是一些常见的应用场景：

排序： 使用Comparator接口对集合进行排序是行为参数化的一个经典例子。 Comparator 接口定义了一个 compare 方法，该方法接受两个对象作为参数，并返回一个整数来表示它们的比较结果。在 Java 8 之前，你通常需要创建一个匿名类来实现 Comparator 接口。但是，使用 Lambda 表达式，你可以非常简洁地定义排序逻辑：
```
// 按照苹果重量升序排序
inventory.sort((Apple a1, Apple a2) -> a1.getWeight() - a2.getWeight());

// 或者使用方法引用
inventory.sort(Comparator.comparingInt(Apple::getWeight));
```
线程： 创建线程时，你需要指定线程要执行的任务。这个任务通常由 Runnable 接口表示，该接口只有一个 run 方法。同样，你可以使用 Lambda 表达式来简洁地定义线程任务：
```
// 创建一个线程并启动
Thread t = new Thread(() -> {
    System.out.println("Hello from a thread!");
});
t.start();
```
GUI 事件处理： 在 GUI 编程中，你需要处理各种用户事件，例如按钮点击、鼠标移动等。这些事件通常通过事件监听器来处理，而监听器接口通常只有一个方法。 Lambda 表达式可以让你非常方便地定义事件处理逻辑：
```
// 给按钮添加点击事件监听器
button.addActionListener((ActionEvent event) -> {
    System.out.println("Button clicked!");
});
```