Java 中将方法作为参数传递

1. 概述

在 Java 中，我们可以使用函数式编程概念，特别是使用 lambda 表达式、方法引用和函数接口，将一个方法作为参数传递给另一个方法。本文中中，我们将探索几种将方法作为参数传递的方法。

2. 使用接口及匿名内部类

Java 8 之前，我们依赖于靠接口和匿名内部类将方法作为参数传递。以下是一个说明这种方法的示例：

interface Operation {
    int execute(int a, int b);
}

首先，我们定义一个名为 Operation 的结果，它只有一个抽象方法 excute()。该方法接收两个整型参数并返回一个整型值。实现该接口的类都必需提供 execute() 方法的实现。

接下来，我们创建一个方法名为 performOperation()，它接收两个整型参数并返回一个 Operation 实例：

int performOperation(int a, int b, Operation operation) {
    return operation.execute(a, b);
}

在该方法中，我们调用 operation.execute(a, b)。这行代码调用了 Operation 实例的 execute() 方法，其中 operation 实例作为参数传入：

然后我们调用 performOperation() 方法，并传入三个参数：

int actualResult = performOperation(5, 3, new Operation() {
    @Override
    public int execute(int a, int b) {
        return a + b;
    }
});

在 performOperation() 方法中，使用匿名内部类创建了一个 Operation 接口的实例。这个内部类没有类名，但它提供了 execute() 方法的动态实现。

在匿名内部类中，execute() 方法被重写了。本例中，它只是简单地将两个整数 a 和 b 进行相加，并返回这两个整数的和。

最后，我们使用断言来验证实现，以确保结果符合我们的预期：

assertEquals(8, actualResult);

3. 使用 Lambda 表达式

在 Java 8 中，lambda 表达式使作为参数的传递方法更加优雅和简洁。以下是我们如何使用 lambda 实现相同的功能：

@FunctionalInterface
interface Operation {
    int execute(int a, int b);
}

我们定义了一个接口 Operation，并使用 @FunctionalInterface 注解来说明该接口只有一个抽象方法。

接下来，我们调用 performOperation() 方法并传递两个整型参数及一个 Operation 接口的实例：

int actualResult = performOperation(5, 3, (a, b) -> a + b);

对于第三个参数，我们传递一个 lambda 表达式 (a, b) -> a + b，而非一个匿名内部类，它表示 Operation 函数接口的一个实例。

其返回的结果应该是一样的：

assertEquals(8, actualResult);

使用 lambda 表达式不仅简化了语法，而且使得代码相比于匿名内部类更具可读性。

4. 使用方法引用

Java 中的方法引用提供了一种将方法作为参数传递的简化方法。它们是调用特定方法的 lambda 表达式的简写。让我们看看如何使用方法引用实现相同的功能。

我们定义了一个名为 add() 的方法，它接受两个整数 a 和 b 作为参数，并返回它们的和：

int add(int a, int b) {
    return a + b;
}

该方法只是简单地将两个整数相加并返回结果。然后该方法使用 object::methodName 或 ClassName::methodName 语法作为引用传入：

int actualResult = performOperation(5, 3, FunctionParameter::add);
assertEquals(8, actualResult);

这里，FunctionParameter::add 是指 FunctionParameter 类中的 add() 方法。它允许我们将 add() 方法定义的行为作为参数传递给另一个方法，即本例中为 performOperation() 方法。

此外，在 performOperation() 方法中，add() 方法的引用被视为 Operation 函数接口的实例，该接口有一个抽象方法 execute()。

5. 使用 Function 类

除了方法引用和 lambda 表达式，Java 8 还引入了 java.util.function 包，该包为常见操作提供了函数接口。其中，BiFunction 是一个函数接口，它表示一个具有两个输入参数和一个返回值的函数。让我们探讨一下如何使用 BiFunction 来实现类似的功能。

首先，我们创建 executeFunction() 方法，该方法接受 BiFunction<Integer, Integer, Integer> 作为第一个参数。这意味着它接收一个函数，该函数接收两个 Integer 值作为输入，并返回一个 Integer：

int executeFunction(BiFunction<Integer, Integer, Integer> function, int a, int b) {
    return function.apply(a, b);
}

apply() 方法用于将函数应用于它的两个参数。接下来，我们可以使用 lambda 表达式创建 BiFunction 的实例，并将其作为参数传递给 executeFunction() 方法：

int actualResult = executeFunction((a, b) -> a + b, 5, 3);

lambda 表达式 (a, b) -> a + b 表示一个将两个输入相加的函数。整数 5 和 3 分别作为第二和第三个参数传入。

最后，我们使用断言验证这一实现是否如我们的预期：

assertEquals(8, actualResult);

6. 使用 Callable 类

我们也可以使用 Callable 将方法作为参数传递。Callable 接口是 java.util.concurrent 包的一部分，表示一个返回结果并可能抛出异常的任务。这在并发编程中特别有用。

让我们探索一下如何使用 Callable 将方法作为参数传递。首先，我们创建 executeCallable() 方法，该方法接受 Callable<Integer> 作为参数。这意味着它将接收一个返回 Integer 的任务：

int executeCallable(Callable<Integer> task) throws Exception {
    return task.call();
}

call() 方法用于执行任务并返回结果。它可能会抛出异常，因此我们需要适当地处理它。我们可以使用 lambda 表达式或匿名内部类定义 Callable 任务。这里，为简单起见，我们使用 lambda 表达式：

Callable<Integer> task = () -> 5 + 3;

这个 lambda 表达式表示一个计算 5 和 3 之和的任务。然后我们可以调用 executeCallable() 方法并将 Callable 任务作为参数传递：

int actualResult = executeCallable(task);
assertEquals(8, actualResult);

使用 Callable 传递方法作为参数提供了一种在并发编程场景中特别有用的替代方法。

7. 小结

本文中，我们探讨了在 Java 中将方法作为参数传递的各种方法。对于简单的操作，由于其简洁性，lambda 表达式或方法引用通常是首选。对于复杂的操作，匿名内部类可能仍然适用。