Introduction

In Java, callbacks are usually implemented by passing an object that exposes a method to be invoked later. Historically that meant interfaces and anonymous classes. In modern Java, it often means a functional interface and a lambda.

The Classic Interface-Based Callback

A callback is simply an agreement: "when this work finishes, call this method." In Java, the most common way to express that agreement is an interface.

1interface ResultCallback {
2    void onComplete(String result);
3}
4
5class Worker {
6    void doWork(ResultCallback callback) {
7        String result = "done";
8        callback.onComplete(result);
9    }
10}
11
12public class Main {
13    public static void main(String[] args) {
14        Worker worker = new Worker();
15        worker.doWork(result -> System.out.println("Callback got: " + result));
16    }
17}

Here ResultCallback defines the callback contract, and Worker invokes it when the work is complete.

Why Lambdas Make This Cleaner

Because ResultCallback has one abstract method, it is a functional interface. That means callers can use a lambda instead of writing an anonymous class.

Without lambdas, older Java code looked more like this:

1worker.doWork(new ResultCallback() {
2    @Override
3    public void onComplete(String result) {
4        System.out.println("Callback got: " + result);
5    }
6});

Both forms are valid. The lambda version is simply more concise.

Callbacks for Success and Failure

Real code often needs more than one callback path. A common pattern is separate success and error methods.

1interface DownloadCallback {
2    void onSuccess(String body);
3    void onError(Exception ex);
4}
5
6class Downloader {
7    void fetch(boolean fail, DownloadCallback callback) {
8        try {
9            if (fail) {
10                throw new IllegalStateException("network error");
11            }
12            callback.onSuccess("payload");
13        } catch (Exception ex) {
14            callback.onError(ex);
15        }
16    }
17}

This makes the control flow explicit and keeps the caller informed about both outcomes.

Asynchronous Callbacks

Callbacks become especially useful when the work does not finish immediately. For example, a background thread can invoke the callback later.

1interface ResultCallback {
2    void onComplete(String result);
3}
4
5class AsyncWorker {
6    void doWorkAsync(ResultCallback callback) {
7        new Thread(() -> {
8            try {
9                Thread.sleep(500);
10                callback.onComplete("async result");
11            } catch (InterruptedException e) {
12                Thread.currentThread().interrupt();
13            }
14        }).start();
15    }
16}

This pattern is simple, but once concurrency gets more serious, Java developers often move toward CompletableFuture, executors, or reactive APIs instead of building many custom callback interfaces by hand.

When to Prefer CompletableFuture

For modern asynchronous Java code, CompletableFuture can be cleaner than manual callbacks because it supports composition.

1import java.util.concurrent.CompletableFuture;
2
3CompletableFuture.supplyAsync(() -> "result")
4        .thenAccept(result -> System.out.println("Got: " + result))
5        .exceptionally(ex -> {
6            ex.printStackTrace();
7            return null;
8        });

This is still callback-style programming, but the callback hooks are part of a richer standard abstraction.

That becomes especially valuable once you need chaining, transformation, timeout handling, or combining several asynchronous results. Manual callback interfaces are fine for simple local APIs, but composition gets messy quickly.

Common Pitfalls

The most common mistake is using a callback interface with too many unrelated methods. Keep the contract focused.

Another mistake is invoking callbacks from background threads without documenting that threading behavior. The caller needs to know what thread the callback runs on.

A third pitfall is using manual callback chains for complex async flows when CompletableFuture or another higher-level abstraction would be clearer.

Summary

• In Java, callbacks are usually implemented with interfaces or functional interfaces.
• Lambdas make single-method callback interfaces concise and readable.
• Separate success and error callbacks when the operation can fail.
• For asynchronous work, document which thread invokes the callback.
• For more complex async composition, CompletableFuture is often better than hand-built callback chains.