Java 回调函数详解及使用

概述

回调函数是一种可以在程序运行时将一个函数作为参数传递给另一个函数，在这个函数执行过程中，如果符合某些条件，就会去执行传递过来的这个函数，这个传递的函数就是回调函数。

在 Java 中，回调函数通常被用于事件监听、异步处理等场合。

回调函数的实现

回调函数的实现通常需要以下三步：

1. 定义一个接口用于回调；
2. 在需要使用回调函数的类中，添加成员变量来接收回调对象；
3. 在需要触发回调的过程中，进行回调。

下面是一个简单的示例：

public interface Callback {
    void onCallback(String message);
}

public class Caller {
    private Callback callback;

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

    public void doSomething() {
        // do something here
        String message = "Done!";
        callback.onCallback(message);
    }
}

public class Receiver implements Callback {
    @Override
    public void onCallback(String message) {
        System.out.println("Received message: " + message);
    }
}

public class Main {
    public static void main(String[] args) {
        Caller caller = new Caller();
        Receiver receiver = new Receiver();
        caller.setCallback(receiver);
        caller.doSomething();
    }
}

在上述示例中，接口 Callback 定义了一个回调方法 onCallback，Caller 类中通过成员变量接收 Callback 对象，然后在 doSomething 方法中触发回调；Receiver 类实现了 Callback 接口，将会被作为回调对象传递到 Caller 类中。

在 Main 类中，通过实例化 Caller 类和 Receiver 类，并调用 setCallback 方法将 Receiver 类作为回调对象传递给 Caller 类，触发回调操作。

回调函数的示例

示例一

下面是一个事件监听的示例，通过回调函数实现按钮点击事件的监听：

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

interface ButtonCallback {
    void onClick(String message);
}

class Button extends JButton {
    private ButtonCallback callback;

    public void setCallback(ButtonCallback callback) {
        this.callback = callback;
        addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                if (callback != null) {
                    callback.onClick(getText());
                }
            }
        });
    }
}

class Receiver implements ButtonCallback {
    @Override
    public void onClick(String message) {
        System.out.println("Button clicked: " + message);
    }
}

class MainFrame extends JFrame {
    public MainFrame() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("Button Demo");
        setSize(400, 300);

        Container contentPane = getContentPane();
        Button button1 = new Button();
        button1.setText("Click me!");
        Receiver receiver = new Receiver();
        button1.setCallback(receiver);
        contentPane.add(button1);
    }
}

public class Main {
    public static void main(String[] args) {
        MainFrame frame = new MainFrame();
        frame.setVisible(true);
    }
}

在上述示例中，Button 类继承自 JButton，添加了回调方法 setCallback，并在使用 addActionListener 方法注册回调动作；Receiver 类实现了 ButtonCallback 接口，将作为回调对象传递给 Button 类；MainFrame 类是一个继承自 JFrame 的界面类，用于展现一个包含按钮的窗口。

在 Main 类中，实例化 MainFrame 类，启动界面。

示例二

下面是一个多线程异步回调的示例，通过回调函数实现异步计算结果的回调：

interface CalculationCallback {
    void onResult(int result);
}

class Calculator {
    private CalculationCallback callback;

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

    public void calculate() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // do some math calculation here
                int result = 42;
                if (callback != null) {
                    callback.onResult(result);
                }
            }
        }).start();
    }
}

class Receiver implements CalculationCallback {
    @Override
    public void onResult(int result) {
        System.out.println("Calculation result: " + result);
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        Receiver receiver = new Receiver();
        calculator.setCallback(receiver);
        calculator.calculate();
        // do some other things here
    }
}

在上述示例中，Calculator 类中定义了一个计算方法 calculate，在其中启动一个新线程进行一些复杂的计算操作，并在计算完成后，通过回调触发 onResult 方法，将计算结果传递给回调对象；Receiver 类实现了 CalculationCallback 接口，将作为回调对象传递给 Calculator 类。

在 Main 类中，实例化 Calculator 类和 Receiver 类，通过 setCallback 方法将 Receiver 类作为回调对象传递给 Calculator 类，然后调用 calculate 方法进行计算操作，在异步计算的过程中，可以继续进行其他的操作。当计算完成后，onResult 方法会被自动调用，并将计算结果输出。