Java中有哪些回调机制?

　　回调机制是一种编程模式，用于在某个特定事件发生时通知或调用预定义的代码片段或函数。在回调机制中，一个函数将另一个函数作为参数传递，并在合适的时机调用该函数。

　　在Java中，有以下几种回调机制可用：

　　1.接口回调

　　这是Java中最常见的回调机制之一。通过定义一个接口，其中包含需要回调的方法，然后在另一个类中实现该接口并提供具体的回调方法。在合适的时机，调用方将调用接口方法，实际执行的代码将在实现接口的类中执行。

　　接下来我们看一个接口回调的示例代码：

// 定义回调接口
interface Callback {
    void onCallback();
}

// 实现回调接口的类
class CallbackImpl implements Callback {
    @Override
    public void onCallback() {
        System.out.println("Callback called");
    }
}

// 调用方类
class Caller {
    private Callback callback;

    public void setCallback(Callback callback) {
        this.callback = callback;
    }

    public void doSomething() {
        // 执行一些操作
        System.out.println("Doing something");

        // 在适当的时候调用回调方法
        if (callback != null) {
            callback.onCallback();
        }
    }
}

// 使用回调机制
public class Main {
    public static void main(String[] args) {
        Caller caller = new Caller();
        Callback callback = new CallbackImpl();
        caller.setCallback(callback);

        caller.doSomething();
    }
}

　　在上面的示例中，Caller类调用doSomething()方法时，会在适当的时机调用回调接口的方法 onCallback()。在Main类中，创建了一个Caller实例和一个CallbackImpl实例，将CallbackImpl实例设置为Caller的回调，当doSomething()被调用时，将触发回调方法。

　　2.事件监听器

　　Java中许多GUI框架都使用事件监听器回调机制。在这种机制下，组件(如按钮、文本框等)注册监听器，用于捕获特定事件的发生，并在事件发生时调用回调方法。

　　接下来我们看一个使用事件监听器的示例代码(使用Swing)：

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Main {
    public static void main(String[] args) {
        JButton button = new JButton("Click me");
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Button clicked");
            }
        });

        JFrame frame = new JFrame("Callback Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(button);
        frame.pack();
        frame.setVisible(true);
    }
}

　　在上面的示例中，创建了一个按钮对象button，并为其添加一个匿名的ActionListener实现。当按钮被点击时，actionPerformed()方法将被调用，并打印出"Button clicked"。

　　3.Future和Callback

　　Java的并发包中提供了Future和Callback接口，用于处理异步任务的回调。Future表示一个可能还没有完成的异步任务的结果，而Callback则是在任务完成时进行回调的接口。

　　接下来是一个使用Future和Callback的示例代码：

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        Future<String> future = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(2000);
                return "Task completed";
            }
        });

        future.addListener(new Runnable() {
            @Override
            public void run() {
                try {
                    String result = future.get();
                    System.out.println(result);
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
        }, executor);

        executor.shutdown();
    }
}

　　在上面的示例中，通过submit()方法提交一个异步任务，返回一个Future对象。然后使用addListener()方法注册一个Runnable回调，在任务完成时会调用该回调方法，并在其中获取任务的结果。

　　4.Java回调函数库

　　除了基本的回调机制外，Java中还有一些开源的回调函数库可用，如Guava、Apache Commons等。这些库提供了丰富的回调功能和工具，使回调的使用更加便捷和灵活。

　　例如，使用Guava库的ListenableFuture和Futures类，可以实现更高级的回调模式。

import com.google.common.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ListeningExecutorService executor = MoreExecutors.newDirectExecutorService();

        ListenableFuture<String> future = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(2000);
                return "Task completed";
            }
        });

        Futures.addCallback(future, new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println(result);
            }

            @Override
            public void onFailure(Throwable t) {
                t.printStackTrace();
            }
        }, executor);

        executor.shutdown();
    }
}

　　在上面的示例中，使用Guava库的ListeningExecutorService和Futures.addCallback()方法实现了异步任务的回调。FutureCallback接口中的onSuccess()方法在任务成功完成时调用，onFailure()方法在任务发生异常时调用。

　　以上便是Java中常见的回调机制。根据具体的应用场景和需求，选择适合的回调机制可以提高代码的灵活性和可维护性。