How Can I Simulate Function Pointers in Java?

Creating Function Pointers in Java

Java lacks the concept of function pointers, which are commonly used to pass functions as arguments to other functions. However, there are alternatives that provide similar functionality, such as anonymous inner classes.

Consider a method that involves a small calculation that differs across multiple methods. An ideal solution would be to pass in a function pointer to handle that line of code.

Anonymous Inner Classes to the Rescue

Anonymous inner classes allow you to create an instance of an interface or abstract class directly within your code without having to define a separate class. This technique can be used to simulate function pointers in Java.

For example, if you want to pass in a function with a String parameter that returns an integer, you can define an interface:

interface StringFunction {
    int func(String param);
}

A method that accepts this function pointer would take a StringFunction instance:

public void takingMethod(StringFunction sf) {
   int i = sf.func("my string");
   // do whatever ...
}

You can call this method like this:

takingMethod(new StringFunction() {
    public int func(String param) {
        // body
    }
});

In Java 8 and later, you can simplify this code using lambda expressions:

takingMethod(param -> bodyExpression);

Anonymous inner classes provide a viable alternative to function pointers in Java by allowing you to pass functions as arguments through an interface implementation. They enable you to create reusable code blocks that can be easily customized for specific tasks.

The above is the detailed content of How Can I Simulate Function Pointers in Java?. For more information, please follow other related articles on the PHP Chinese website!