面试题：简述列举 Java 中有哪些回调机制 ?

Java 中的回调机制

回调机制是一种常见的编程模式，用于在某个操作完成后通知调用者或执行特定的逻辑。Java 中有多种实现回调的方式，以下是常见的回调机制：

1. 接口回调

描述：
- 通过定义接口，将回调方法抽象出来，调用者实现该接口并传入回调对象。
- 这是 Java 中最常用的回调机制。

示例：


// 定义回调接口
interface Callback {
    void onComplete(String result);
}
// 调用者实现回调接口
class Worker {
    void doWork(Callback callback) {
        // 模拟耗时操作
        String result = "Work Done";
        callback.onComplete(result); // 调用回调方法
    }
}
// 使用回调
public class Main {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.doWork(new Callback() {
            @Override
            public void onComplete(String result) {
                System.out.println("Callback received: " + result);
            }
        });
    }
}
// 定义回调接口
interface Callback {
    void onComplete(String result);
}

// 调用者实现回调接口
class Worker {
    void doWork(Callback callback) {
        // 模拟耗时操作
        String result = "Work Done";
        callback.onComplete(result); // 调用回调方法
    }
}

// 使用回调
public class Main {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.doWork(new Callback() {
            @Override
            public void onComplete(String result) {
                System.out.println("Callback received: " + result);
            }
        });
    }
}
// 定义回调接口
interface Callback {
    void onComplete(String result);
}

// 调用者实现回调接口
class Worker {
    void doWork(Callback callback) {
        // 模拟耗时操作
        String result = "Work Done";
        callback.onComplete(result); // 调用回调方法
    }
}

// 使用回调
public class Main {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.doWork(new Callback() {
            @Override
            public void onComplete(String result) {
                System.out.println("Callback received: " + result);
            }
        });
    }
}

2. Lambda 表达式（Java 8+）

描述：
- 在 Java 8 及以上版本中，可以使用 Lambda 表达式简化接口回调的实现。
- 适用于函数式接口（只有一个抽象方法的接口）。

示例：


// 使用 Lambda 表达式实现回调
public class Main {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.doWork(result -> System.out.println("Callback received: " + result));
    }
}
// 使用 Lambda 表达式实现回调
public class Main {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.doWork(result -> System.out.println("Callback received: " + result));
    }
}
// 使用 Lambda 表达式实现回调
public class Main {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.doWork(result -> System.out.println("Callback received: " + result));
    }
}

3. Future 和 Callable

描述：
- Future 和 Callable 是 Java 并发编程中的回调机制，用于异步获取任务执行结果。
- Callable 表示一个可以返回结果的任务，Future 用于获取任务的结果。

示例：


import java.util.concurrent.*;
public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() -> {
            // 模拟耗时操作
            Thread.sleep(1000);
            return "Task Done";
        });
        // 获取回调结果
        String result = future.get();
        System.out.println("Callback received: " + result);
        executor.shutdown();
    }
}
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() -> {
            // 模拟耗时操作
            Thread.sleep(1000);
            return "Task Done";
        });

        // 获取回调结果
        String result = future.get();
        System.out.println("Callback received: " + result);
        executor.shutdown();
    }
}
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() -> {
            // 模拟耗时操作
            Thread.sleep(1000);
            return "Task Done";
        });

        // 获取回调结果
        String result = future.get();
        System.out.println("Callback received: " + result);
        executor.shutdown();
    }
}

4. 事件监听器（Observer 模式）

描述：
- 事件监听器是一种基于观察者模式的回调机制，常用于 GUI 编程（如 Swing、JavaFX）。
- 通过注册监听器，在事件发生时触发回调方法。

示例：


import java.util.ArrayList;
import java.util.List;
// 定义事件监听器接口
interface EventListener {
    void onEvent(String event);
}
// 事件源
class EventSource {
    private List<EventListener> listeners = new ArrayList<>();
    void addListener(EventListener listener) {
        listeners.add(listener);
    }
    void triggerEvent(String event) {
        for (EventListener listener : listeners) {
            listener.onEvent(event); // 触发回调
        }
    }
}
// 使用事件监听器
public class Main {
    public static void main(String[] args) {
        EventSource source = new EventSource();
        source.addListener(event -> System.out.println("Event received: " + event));
        source.triggerEvent("Button Clicked");
    }
}
import java.util.ArrayList;
import java.util.List;

// 定义事件监听器接口
interface EventListener {
    void onEvent(String event);
}

// 事件源
class EventSource {
    private List<EventListener> listeners = new ArrayList<>();

    void addListener(EventListener listener) {
        listeners.add(listener);
    }

    void triggerEvent(String event) {
        for (EventListener listener : listeners) {
            listener.onEvent(event); // 触发回调
        }
    }
}

// 使用事件监听器
public class Main {
    public static void main(String[] args) {
        EventSource source = new EventSource();
        source.addListener(event -> System.out.println("Event received: " + event));
        source.triggerEvent("Button Clicked");
    }
}
import java.util.ArrayList;
import java.util.List;

// 定义事件监听器接口
interface EventListener {
    void onEvent(String event);
}

// 事件源
class EventSource {
    private List<EventListener> listeners = new ArrayList<>();

    void addListener(EventListener listener) {
        listeners.add(listener);
    }

    void triggerEvent(String event) {
        for (EventListener listener : listeners) {
            listener.onEvent(event); // 触发回调
        }
    }
}

// 使用事件监听器
public class Main {
    public static void main(String[] args) {
        EventSource source = new EventSource();
        source.addListener(event -> System.out.println("Event received: " + event));
        source.triggerEvent("Button Clicked");
    }
}

5. CompletableFuture（Java 8+）

描述：
- CompletableFuture 是 Java 8 引入的异步编程工具，支持链式调用和回调。
- 可以在任务完成后触发回调方法。

示例：


import java.util.concurrent.CompletableFuture;
public class Main {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            // 模拟耗时操作
            return "Task Done";
        }).thenAccept(result -> {
            System.out.println("Callback received: " + result);
        });
        // 防止主线程退出
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            // 模拟耗时操作
            return "Task Done";
        }).thenAccept(result -> {
            System.out.println("Callback received: " + result);
        });

        // 防止主线程退出
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            // 模拟耗时操作
            return "Task Done";
        }).thenAccept(result -> {
            System.out.println("Callback received: " + result);
        });

        // 防止主线程退出
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

6. Spring 框架中的回调

描述：
- 在 Spring 框架中，回调机制广泛应用于生命周期管理、事件处理等场景。
- 例如，InitializingBean 和 DisposableBean 接口分别用于初始化和销毁时的回调。

示例：


import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
public class MyBean implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() {
        System.out.println("Bean initialized");
    }
    @Override
    public void destroy() {
        System.out.println("Bean destroyed");
    }
}
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class MyBean implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() {
        System.out.println("Bean initialized");
    }

    @Override
    public void destroy() {
        System.out.println("Bean destroyed");
    }
}
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class MyBean implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() {
        System.out.println("Bean initialized");
    }

    @Override
    public void destroy() {
        System.out.println("Bean destroyed");
    }
}