Java中的回调机制使用方式

// 定义回调接口
interface ClickListener {
    void onClick();
}

// 按钮类
class Button {
    private ClickListener listener;
    
    // 设置回调监听器
    public void setClickListener(ClickListener listener) {
        this.listener = listener;
    }
    
    // 模拟按钮被点击
    public void click() {
        System.out.println("按钮被点击了");
        if (listener != null) {
            listener.onClick(); // 触发回调
        }
    }
}

public class InterfaceCallbackDemo {
    public static void main(String[] args) {
        Button button = new Button();
        
        // 设置回调实现
        button.setClickListener(new ClickListener() {
            @Override
            public void onClick() {
                System.out.println("回调执行：按钮点击事件处理");
                System.out.println("回调执行了~");
            }
        });
        
        button.click(); // 触发点击事件
    }
}

按钮被点击了
回调执行：按钮点击事件处理
回调执行了~

// 定义抽象回调类
abstract class TaskHandler {
    // 抽象回调方法
    public abstract void onComplete(String result);
    
    // 可以有具体实现方法
    public void onStart() {
        System.out.println("任务开始处理");
    }
}

// 任务执行类
class TaskExecutor {
    public void execute(TaskHandler handler) {
        handler.onStart();
        
        // 模拟任务执行
        try {
            Thread.sleep(1000);
            handler.onComplete("任务完成");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class AbstractClassCallbackDemo {
    public static void main(String[] args) {
        TaskExecutor executor = new TaskExecutor();
        
        // 使用匿名类实现抽象回调类
        executor.execute(new TaskHandler() {
            @Override
            public void onComplete(String result) {
                System.out.println("回调结果: " + result);
            }
        });
    }
}

任务开始处理
回调结果: 任务完成

import java.util.function.BiFunction;

public class LambdaCallbackDemo {
    public static void main(String[] args) {
        // 使用BiFunction作为回调接口
        calculate(5, 3, (a, b) -> a + b);  // 加法
        calculate(5, 3, (a, b) -> a * b);  // 乘法
        
        // 更复杂的示例，数据处理回调
        processData("Hello", 
            data -> {
                String result = data + " World!";
                System.out.println("处理结果: " + result);
                return result;
            },
            error -> System.err.println("错误: " + error)
            );
        // 
        processData(null,
                data -> data + " World!",
                error -> System.err.println("捕获到错误: " + error)
                );
    }
    
    // 计算方法，接收操作回调
    public static void calculate(int a, int b, BiFunction<Integer, Integer, Integer> operation) {
        int result = operation.apply(a, b);
        System.out.println("计算结果: " + result);
    }
    
    // 数据处理方法，接收成功和失败回调
    public static void processData(String input, 
                                  java.util.function.Function<String, String> successHandler,
                                  java.util.function.Consumer<Exception> errorHandler) {
        try {
            if (input == null) {
                throw new IllegalArgumentException("输入不能为null");
            }
            String result = successHandler.apply(input);
        } catch (Exception e) {
            errorHandler.accept(e);
        }
    }
}

计算结果: 8
计算结果: 15
处理结果: Hello World!
捕获到错误: java.lang.IllegalArgumentException: 输入不能为null

// 同步回调接口
interface SyncCallback {
    void onComplete(String result);
}

class SyncProcessor {
    public void process(String input, SyncCallback callback) {
        System.out.println("处理线程: " + Thread.currentThread().getName());
        // 同步处理
        String result = input.toUpperCase();
        // 同步调用回调
        callback.onComplete(result);
    }
}

public class SyncCallbackDemo {
    public static void main(String[] args) {
        SyncProcessor processor = new SyncProcessor();
        
        System.out.println("主线程: " + Thread.currentThread().getName());
        
        processor.process("hello", result -> {
            System.out.println("回调线程: " + Thread.currentThread().getName());
            System.out.println("同步结果: " + result);
        });
        
        System.out.println("主线程继续执行...");
    }
}

主线程: main
处理线程: main
回调线程: main
同步结果: HELLO
主线程继续执行...

// 异步回调接口
interface AsyncCallback {
    void onComplete(String result);
}

class AsyncProcessor {
    public void process(String input, AsyncCallback callback) {
        System.out.println("调用线程: " + Thread.currentThread().getName());
        
        // 启动新线程异步处理
        new Thread(() -> {
            System.out.println("处理线程: " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000); // 模拟耗时操作
                String result = input.toUpperCase();
                callback.onComplete(result);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

public class AsyncCallbackDemo {
    public static void main(String[] args) {
        AsyncProcessor processor = new AsyncProcessor();
        
        System.out.println("主线程: " + Thread.currentThread().getName());
        
        processor.process("hello", result -> {
            System.out.println("回调线程: " + Thread.currentThread().getName());
            System.out.println("异步结果: " + result);
        });
        
        System.out.println("主线程继续执行...");
        
        // 防止主线程过早退出
        try { Thread.sleep(1500); } catch (InterruptedException e) {}
    }
}

主线程: main
调用线程: main
主线程继续执行...
处理线程: Thread-0
回调线程: Thread-0
异步结果: HELLO