How to Simulate Function Pointers in Java: Interfaces, Lambdas, and More

1. Introduction

In C or C++ we can store functions in variables and pass them, which is called a function pointer. Java has no function pointers, but we can achieve the same behavior with other techniques. This tutorial explores several common ways to simulate function pointers in Java.

2. Interfaces and Anonymous Classes

Before Java 8, the standard way is to define a single‑method interface and implement it with an anonymous class. This remains valuable for legacy code or environments without Java 8+.

Define an operation interface:

public interface MathOperation {
    int operate(int a, int b);
}

The interface has a single method operate() that takes two integers and returns a result.

Define a class that uses the interface:

public class Calculator {
    public int calculate(int a, int b, MathOperation operation) {
        return operation.operate(a, b);
    }
}

Test with an anonymous class for addition:

@Test
void givenAnonymousAddition_whenCalculate_thenReturnSum() {
    Calculator calculator = new Calculator();
    MathOperation addition = new MathOperation() {
        @Override
        public int operate(int a, int b) {
            return a + b;
        }
    };
    int result = calculator.calculate(2, 3, addition);
    assertEquals(5, result);
}

The interface method is invoked directly, and the test confirms 2 + 3 equals 5.

Pros: Works on all Java versions, provides clear type safety.

Cons: Requires boilerplate code; each operation needs its own class, which can clutter the codebase.

3. Lambda Expressions (Java 8+)

Java 8 introduced lambda expressions, offering a shorter, more readable way to pass behavior.

Reuse the same MathOperation interface:

@Test
void givenLambdaSubtraction_whenCalculate_thenReturnDifference() {
    Calculator calculator = new Calculator();
    MathOperation subtract = (a, b) -> a - b;
    int result = calculator.calculate(10, 4, subtract);
    assertEquals(6, result);
}

The lambda (a, b) -> a - b inlines the logic and matches the interface signature.

The Calculator still receives the interface and calls its method; only the behavior is passed more concisely.

Pros: Improves readability and reduces boilerplate, especially for simple operations.

4. Built‑in Functional Interfaces

Java 8 also provides predefined functional interfaces in java.util.function, eliminating the need to write custom interfaces.

Example using BiFunction:

@Test
void givenBiFunctionMultiply_whenApply_thenReturnProduct() {
    BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
    int result = multiply.apply(6, 7);
    assertEquals(42, result);
}

BiFunction<T,U,R>

represents a function that takes two arguments and returns a result. It can be stored in a variable and invoked with apply().

It can also be used in methods:

public class AdvancedCalculator {
    public int compute(int a, int b, BiFunction<Integer, Integer, Integer> operation) {
        return operation.apply(a, b);
    }
}

Test division with BiFunction:

@Test
void givenBiFunctionDivide_whenCompute_thenReturnQuotient() {
    AdvancedCalculator calculator = new AdvancedCalculator();
    BiFunction<Integer, Integer, Integer> divide = (a, b) -> a / b;
    int result = calculator.compute(20, 4, divide);
    assertEquals(5, result);
}

When the function matches predefined interfaces like Function, BiFunction, or Predicate, this approach works well.

Cons: Limited when custom parameter or return types are needed.

5. Method References

Method references provide a shorthand for lambdas that call existing methods.

Define a utility method:

public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
}

Use a method reference instead of a lambda:

@Test
void givenMethodReference_whenCalculate_thenReturnSum() {
    Calculator calculator = new Calculator();
    MathOperation operation = MathUtils::add;
    int result = calculator.calculate(5, 10, operation);
    assertEquals(15, result);
}

The reference MathUtils::add matches MathOperation.operate(), so the compiler accepts it.

Pros: Makes code concise when reusing existing static or instance methods.

Cons: Less flexible for custom logic compared to lambdas or interfaces.

6. Reflection

Java also allows dynamic method invocation via reflection, a technique often used in frameworks or tools where methods must be discovered at runtime.

Define a dynamic operation class:

public class DynamicOps {
    public int power(int a, int b) {
        return (int) Math.pow(a, b);
    }
}

Invoke the method reflectively:

@Test
void givenReflection_whenInvokePower_thenReturnResult() throws Exception {
    DynamicOps ops = new DynamicOps();
    Method method = DynamicOps.class.getMethod("power", int.class, int.class);
    int result = (int) method.invoke(ops, 2, 3);
    assertEquals(8, result);
}

Reflection is powerful for dynamic loading or plugin systems but is slower, less safe, and lacks compile‑time type checking.

7. Command Pattern

The command pattern encapsulates behavior in separate objects, useful for parameterizing, queuing, or delaying execution.

Define the same MathOperation interface and concrete command classes such as AddCommand:

public class AddCommand implements MathOperation {
    @Override
    public int operate(int a, int b) {
        return a + b;
    }
}

Test the command:

@Test
void givenAddCommand_whenCalculate_thenReturnSum() {
    Calculator calculator = new Calculator();
    MathOperation add = new AddCommand();
    int result = calculator.calculate(3, 7, add);
    assertEquals(10, result);
}

This approach is effective when behaviors need to be passed as objects, supporting undo, history, or delayed execution.

8. Enum‑Based Implementation

Java enums can encapsulate logic by defining abstract methods that each constant overrides.

public enum MathOperationEnum {
    ADD {
        @Override
        public int apply(int a, int b) { return a + b; }
    },
    SUBTRACT {
        @Override
        public int apply(int a, int b) { return a - b; }
    },
    MULTIPLY {
        @Override
        public int apply(int a, int b) { return a * b; }
    },
    DIVIDE {
        @Override
        public int apply(int a, int b) {
            if (b == 0) throw new ArithmeticException("Division by zero");
            return a / b;
        }
    };
    public abstract int apply(int a, int b);
}

Use it in a calculator:

public class EnumCalculator {
    public int calculate(int a, int b, MathOperationEnum operation) {
        return operation.apply(a, b);
    }
}

Test subtraction:

@Test
void givenEnumSubtract_whenCalculate_thenReturnResult() {
    EnumCalculator calculator = new EnumCalculator();
    int result = calculator.calculate(9, 4, MathOperationEnum.SUBTRACT);
    assertEquals(5, result);
}

This pattern offers type safety and centralizes a fixed set of operations.

9. Conclusion

The article explored various techniques for simulating function pointers in Java, highlighting that lambda expressions and built‑in functional interfaces are preferred for modern development due to their simplicity and readability, while interfaces with anonymous classes remain reliable for legacy environments.