Java中回调函数
回调函数
目录
- 回调函数
- 1、回调函数概念
- 2、回调函数的实现方式
- 3、回调函数的使用场景
- 4、回调函数lambda简化实现方式
- 5、单线程聊天例子：
1、回调函数概念
回调：回调函数是指将方法作为参数传给另一个方法，在特定事件或特定条件后执行传递的方法。
方法参数一般通过接口(对象)实现，调用者实现接口，并将接口实例传给调用方，在特定条件后调用。
其实回调函数就是处理一些逻辑后，知道自己处理的结果和响应，比如点击鼠标事件：点击后我怎么知道鼠标是点击成功的。发送消息：发送后我怎么知道自己发送消息对方接收了，这时对方就要调我的方法通知我，这时这个方法就是回调方法。
2、回调函数的实现方式
通过接口实现回调的基本步骤如下：
- 定义接口：接口中包含需要回调的方法。
- 实现接口：调用者实现接口，并在实现中定义具体行为。
- 注册接口实例：将接口实例传递给调用方。
- 触发回调：调用方在适当的时机调用接口方法。
/**
* 回调函数接口
*/
public interface CallBack {
// 成功后调用函数
String success();
// 失败后调用函数
String failed();
}
public class CallBackHandler implements CallBack{
@Override
public String success() {
// 可以加复杂逻辑，比如调其它接口
System.out.println("回调成功");
return "回调成功";
}
@Override
public String failed() {
// // 可以加复杂逻辑，比如调其它接口
System.out.println("失败了，请重新尝试访问!");
return "失败了，请重新尝试访问!";
}
}
public class Caller {
private CallBack callBack;
public Caller(CallBack callBack) {
this.callBack = callBack;
}
public String doSomeThing(Boolean mes){
if(mes) {
return callBack.success();
} else {
return callBack.failed();
}
}
}
public class Main {
public static void main(String[] args) {
// 执行一些复杂逻辑后不想在此方法添加复杂逻辑，使用回调方法，实现解耦，代码复用，灵活
Boolean flag = true;
// Caller对象是调用方执行的操作，CallBackHandler()是回调方法，并实现注册回调
Caller caller = new Caller(new CallBackHandler());
try {
// 触发事件
caller.doSomeThing(flag);
} catch (Exception e){
flag = false;
caller.doSomeThing(flag);
}
}
}
3、回调函数的使用场景
在GUI编程中，如用户点击事件，鼠标按钮等事件用于广泛。
public class Main {
public static void main(String[] args) {
JFrame frame = new JFrame("Callback");
JButton button = new JButton("Please Click!");
// 添加回调
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Button clicked!");
}
});
frame.add(button);
frame.setSize(200, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
在异步编程中，异步任务完成或者失败后执行对应方法。
// 异步任务接口
interface Callback {
void run(String result);
}
// 异步任务实现类
class AsyncTask {
private Callback callback;
public AsyncTask(Callback callback1) {
this.callback = callback1;
}
public void execute() {
System.out.println("Task is running...");
try {
Thread.sleep(2000); // 模拟任务执行
} catch (InterruptedException e) {
e.printStackTrace();
}
callback.run("Task completed successfully!");
}
}
// 测试异步任务
public class AsyncTaskDemo {
public static void main(String[] args) {
AsyncTask task = new AsyncTask(new Callback() {
@Override
public void run(String result) {
System.out.println("Callback received: " + result);
}
});
task.execute();
}
在观察者模式中，观察者实现方法，在被观察者状态改变时接收通知。
观察者模式
4、回调函数lambda简化实现方式
以测试异步任务为例：
public class AsyncTaskDemo {
public static void main(String[] args) {
AsyncTask task = new AsyncTask(run -> {
System.out.println("Callback received: " + run );
});
task.execute();
}
5、单线程聊天例子：
// ---------------------- Tom 接口 -----------------------------
public interface Tom {
// 发送消息
void sendMessTom(String text,MarrayHandler marrayHandler);
// 接收到了消息
void receiveMessTom(String text,MarrayHandler marrayHandler);
// 通知我
Boolean noticeMeTom(Boolean flag);
}
// ---------------------- Tom 实现 -----------------------------
public class TomHandler implements Tom {
private MarrayHandler marrayHandler;
@Override
public void sendMessTom(String text,MarrayHandler handler) {
// 发消息的动作就是要让接收方接收消息，接收之后调用发送者的回调方法noticeMe，通知消息接收到了，你可以再发了
System.out.println("Tom 开始发消息给Marry了");
this.marrayHandler = handler;
marrayHandler.receiveMessMarry(text,this);
}
@Override
public void receiveMessTom(String text,MarrayHandler handler) {
this.marrayHandler = handler;
if(StringUtils.isNotEmpty(text)){
System.out.println("Tom 接收到了信息，信息为:"+text);
Boolean b = marrayHandler.noticeMeMarry(true);
if(b){
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
this.sendMessTom(s,marrayHandler);
}
}
}
@Override
public Boolean noticeMeTom(Boolean flag) {
if(flag){
return true;
}
return false;
}
}
// ---------------------- Marry 接口 -----------------------------
public interface Marry {
// 发送消息
void sendMessMarry(String text,TomHandler tomHandler);
// 接收到了消息
void receiveMessMarry(String text,TomHandler tomHandler);
// 通知我
Boolean noticeMeMarry(Boolean flag);
}
// ---------------------- Marry 接口实现 -----------------------------
public class MarrayHandler implements Marry {
private TomHandler tomHandler;
@Override
public void sendMessMarry(String text,TomHandler handler) {
System.out.println("Marry 开始发消息给Tom了");
this.tomHandler = handler ;
tomHandler.receiveMessTom(text,this);
}
@Override
public void receiveMessMarry(String text,TomHandler handler) {
this.tomHandler = handler ;
if(StringUtils.isNotEmpty(text)){
System.out.println("Marry 接收到了信息，信息为:"+text);
Boolean b = tomHandler.noticeMeTom(true);
if(b){
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
this.sendMessMarry(s,tomHandler);
}
}
}
@Override
public Boolean noticeMeMarry(Boolean flag) {
if(flag){
return true;
}
return false;
}
}
// ------------------- 调用 ----------------------
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
String next = s.nextLine();
new TomHandler().sendMessTom(next,new MarrayHandler());
}
}
结果：
