Introduction

Java does not have C-style function pointers, but it does have several ways to pass behavior around. In modern Java, the nearest everyday substitute is a functional interface used with a lambda expression or method reference.

The Practical Answer

If by "function pointer" you mean "a value that represents some callable behavior that I can pass to another method," then in Java the usual substitutes are:

• functional interfaces
• lambdas
• method references

This is the standard modern style.

Functional Interface Example

A functional interface is an interface with exactly one abstract method. That makes it a target for lambdas.

1@FunctionalInterface
2interface Operation {
3    int apply(int a, int b);
4}
5
6public class Main {
7    static int run(Operation op, int a, int b) {
8        return op.apply(a, b);
9    }
10
11    public static void main(String[] args) {
12        Operation add = (x, y) -> x + y;
13        Operation multiply = (x, y) -> x * y;
14
15        System.out.println(run(add, 2, 3));
16        System.out.println(run(multiply, 2, 3));
17    }
18}

This gives you much of what a function pointer is used for in other languages: behavior passed as data.

Built-In Functional Interfaces

You often do not even need to define your own interface. Java ships with many in java.util.function.

1import java.util.function.IntBinaryOperator;
2
3public class Main {
4    static int calculate(IntBinaryOperator op, int a, int b) {
5        return op.applyAsInt(a, b);
6    }
7
8    public static void main(String[] args) {
9        System.out.println(calculate((x, y) -> x - y, 10, 4));
10    }
11}

Some common choices are:

• 'Supplier'
• 'Consumer'
• 'Function'
• 'Predicate'
• 'BiFunction'
• 'IntBinaryOperator'

These are usually the cleanest starting point.

Method References

If the behavior already exists as a method, a method reference is the most pointer-like syntax Java offers.

1import java.util.function.IntBinaryOperator;
2
3public class Main {
4    static int add(int a, int b) {
5        return a + b;
6    }
7
8    public static void main(String[] args) {
9        IntBinaryOperator op = Main::add;
10        System.out.println(op.applyAsInt(5, 7));
11    }
12}

Main::add is not a raw memory address like a C function pointer, but it serves a similar everyday role: a named callable target passed around as a value.

What Java Does Not Offer

Java does not expose direct function addresses the way C does. That means you do not get:

• raw pointer arithmetic
• arbitrary calls through memory addresses
• low-level function-address manipulation

That restriction is intentional and fits Java's managed-runtime design.

So the substitute is conceptual, not literal. You are passing an object that represents behavior, not a machine-level code pointer.

Pre-Java 8 Style

Before lambdas, Java used anonymous classes for the same idea.

1interface Task {
2    void run();
3}
4
5public class Main {
6    static void execute(Task task) {
7        task.run();
8    }
9
10    public static void main(String[] args) {
11        execute(new Task() {
12            @Override
13            public void run() {
14                System.out.println("running");
15            }
16        });
17    }
18}

This is still valid, but lambdas are shorter and usually clearer for single-method behavior.

Lower-Level Alternatives

If you need something more dynamic than normal lambdas, Java also has:

• reflection
• 'MethodHandle'

Those are not the nearest substitute for everyday function pointers, though. They are lower-level invocation tools and are usually reserved for frameworks, dynamic libraries, or advanced metaprogramming.

For normal application code, functional interfaces are the right abstraction.

When to Use Which Style

A simple rule:

• existing method already matches: use a method reference
• small inline behavior: use a lambda
• reusable domain-specific callback: define a functional interface

That covers most Java use cases that would call for function pointers in other languages.

Common Pitfalls

Trying to translate C-style pointer thinking directly into Java usually leads to overcomplicated designs. Java's callable abstractions are object-oriented rather than memory-address-based.

Using reflection when a functional interface would do makes code slower, more fragile, and harder to read.

Defining a custom interface for every tiny callback can be unnecessary when built-in interfaces from java.util.function already fit the job.

Confusing method references with immediate method calls is also common. Main::add refers to behavior, while Main.add(1, 2) actually executes it.

Summary

• Java has no direct C-style function pointers.
• The nearest normal substitute is a functional interface used with a lambda or method reference.
• Built-in interfaces in java.util.function cover many common callback shapes.
• Method references are the most pointer-like everyday syntax in modern Java.
• Reflection and MethodHandle exist, but they are more advanced tools than the usual substitute.