How to Pass Method as Parameter in Java

1. Introduction

In Java, we can pass a method as a parameter to another method using functional programming concepts, specifically using lambda expressions, method references, and functional interfaces. In this tutorial, we’ll explore a few ways to pass a method as a parameter.

2. Using Interfaces and Anonymous Inner Classes

Before Java 8, we relied on interfaces and anonymous inner classes to pass methods as parameters. Here’s an example to illustrate this approach:

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

We define an interface named Operation with a single abstract method execute(). This method takes two integers as parameters and returns an integer. Any class that implements this interface must provide an implementation for the execute() method.

Next, we create a method called performOperation() to take in two integer parameters and an instance of Operation:

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

Inside this method, we call operation.execute(a, b). This line of code invokes the execute() method of the Operation instance that is passed as a parameter.

We then invoke the performOperation() method and pass in three arguments:

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

Inside the performOperation() method, a new instance of the Operation interface is created using an anonymous inner class. This class doesn’t have a name, but it provides an implementation for the execute() method on the fly.

Within the anonymous inner class, the execute() method is overridden. In this case, it simply adds the two integers a and b, and returns the sum of the two integers.

Finally, let’s verify our implementation using an assertion to ensure the result is as expected:

assertEquals(8, actualResult);

3. Using Lambda Expressions

With Java 8, lambda expressions made passing methods as parameters more elegant and concise. Here’s how we can achieve the same functionality using lambdas:

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

We define an interface Operation and use the @FunctionalInterface annotation to indicate that this interface has exactly one abstract method.

Next, we invoke the performOperation() method and pass in two integer parameters and an instance of the Operation interface:

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

For the third argument, instead of an anonymous inner class, we pass a lambda expression (a, b) -> a + b, which represents an instance of the Operation functional interface.

We should get back the same result:

assertEquals(8, actualResult);

Using lambda expressions simplifies the syntax and makes the code more readable compared to anonymous inner classes.

4. Using Method References

Method references in Java provide a streamlined way to pass methods as parameters. They serve as shorthand for lambda expressions that invoke a specific method. Let’s see how we can achieve the same functionality using method references.

We define a method named add() that takes two integers a and b as parameters and returns their sum:

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

This method simply adds the two integers together and returns the result. Then, the method is passed as a reference using the syntax object::methodName or  ClassName::methodName:

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

Here, FunctionParameter::add refers to the add() method within the FunctionParameter class. It allows us to pass the behavior defined by the add() method as an argument to another method, in this case, the performOperation() method.

Moreover, in the performOperation() method, the add() method reference is treated as an instance of the Operation functional interface, which has a single abstract method execute().

5. Using Function Class

In addition to method references and lambda expressions, Java 8 introduced the java.util.function package, which provides functional interfaces for common operations. Among these, BiFunction is a functional interface that represents a function with two input parameters and a return value. Let’s explore how to use BiFunction to achieve similar functionality.

First, we create the executeFunction() method that accepts a BiFunction<Integer, Integer, Integer> as the first parameter. This means it receives a function that takes in two Integer values as input and returns an Integer:

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

The apply() method is used to apply the function to its two arguments. Next, we can create an instance of BiFunction using a lambda expression and pass it as a parameter to the executeFunction() method:

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

This lambda expression (a, b) -> a + b represents a function that sums its two inputs. The integers 5 and 3 are passed as the second and third arguments respectively.

Finally, we use an assertion to verify that our implementation works as expected:

assertEquals(8, actualResult);

6. Using Callable Class

We can also use Callable to pass methods as parameters. The Callable interface is part of the java.util.concurrent package and represents a task that returns a result and may throw an exception. This can be particularly useful in concurrent programming.

Let’s explore how to use Callable to pass methods as parameters. First, we create the executeCallable() method that accepts a Callable<Integer> as a parameter. This means it receives a task that returns an Integer:

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

The call() method is used to execute the task and return the result. It can throw an exception, so we need to handle it appropriately. We can define a Callable task using a lambda expression or an anonymous inner class. Here, we use a lambda expression for simplicity:

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

This lambda expression represents a task that computes the sum of 5 and 3. Then we can invoke the executeCallable() method and pass the Callable task as a parameter:

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

Using Callable to pass methods as parameters provides an alternative approach that is particularly useful in concurrent programming scenarios.

7. Conclusion

In this article, we’ve explored various ways to pass methods as parameters in Java. For simple operations, lambda expressions or method references are often preferred due to their conciseness. For complex operations, anonymous inner classes might still be suitable.