Java案例如何实现接口回调？

wen java案例 2026-06-07 310

Java接口回调实现案例

接口回调是一种常见的编程模式，允许一个对象在特定事件发生时通知另一个对象,下面通过几个具体案例来演示。

Java案例如何实现接口回调？

简单计算器回调

定义回调接口

// 计算结果回调接口
public interface CalculatorCallback {
    void onResult(int result);
    void onError(String errorMessage);
}

创建计算器类

public class Calculator {
    // 执行计算并回调
    public void calculate(int a, int b, String operation, CalculatorCallback callback) {
        try {
            int result = 0;
            switch (operation) {
                case "+":
                    result = a + b;
                    break;
                case "-":
                    result = a - b;
                    break;
                case "*":
                    result = a * b;
                    break;
                case "/":
                    if (b == 0) {
                        callback.onError("除数不能为0");
                        return;
                    }
                    result = a / b;
                    break;
                default:
                    callback.onError("不支持的运算操作");
                    return;
            }
            callback.onResult(result);
        } catch (Exception e) {
            callback.onError("计算异常：" + e.getMessage());
        }
    }
}

使用回调

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        // 方式1：匿名内部类实现
        calculator.calculate(10, 5, "+", new CalculatorCallback() {
            @Override
            public void onResult(int result) {
                System.out.println("计算结果: " + result);
            }
            @Override
            public void onError(String errorMessage) {
                System.err.println("错误: " + errorMessage);
            }
        });
        // 方式2：Lambda表达式实现（Java 8+）
        calculator.calculate(10, 0, "/", 
            result -> System.out.println("计算结果: " + result),
            error -> System.err.println("错误: " + error)
        );
    }
}

下载进度回调

// 下载进度回调接口
public interface DownloadCallback {
    void onProgress(int progress, long downloadedBytes, long totalBytes);
    void onComplete(String filePath);
    void onFailed(Exception e);
}
// 下载器类
public class FileDownloader {
    public void download(String url, String savePath, DownloadCallback callback) {
        new Thread(() -> {
            try {
                // 模拟下载过程
                for (int i = 0; i <= 100; i += 10) {
                    Thread.sleep(500); // 模拟下载耗时
                    long totalBytes = 1024 * 1024; // 1MB
                    long downloadedBytes = totalBytes * i / 100;
                    // 回调进度
                    if (callback != null) {
                        callback.onProgress(i, downloadedBytes, totalBytes);
                    }
                }
                // 下载完成
                if (callback != null) {
                    callback.onComplete(savePath);
                }
            } catch (Exception e) {
                if (callback != null) {
                    callback.onFailed(e);
                }
            }
        }).start();
    }
}
// 使用示例
public class Main {
    public static void main(String[] args) {
        FileDownloader downloader = new FileDownloader();
        downloader.download("https://example.com/file.zip", "/downloads/file.zip", 
            new DownloadCallback() {
                @Override
                public void onProgress(int progress, long downloadedBytes, long totalBytes) {
                    System.out.printf("下载进度: %d%%, 已下载: %d/%d KB%n", 
                        progress, downloadedBytes / 1024, totalBytes / 1024);
                }
                @Override
                public void onComplete(String filePath) {
                    System.out.println("下载完成: " + filePath);
                }
                @Override
                public void onFailed(Exception e) {
                    System.err.println("下载失败: " + e.getMessage());
                }
            }
        );
        System.out.println("下载任务已启动...");
    }
}

按钮点击事件回调（模拟GUI）

// 点击事件监听器接口
public interface OnClickListener {
    void onClick(View v);
}
// 视图类
public class View {
    private OnClickListener clickListener;
    public void setOnClickListener(OnClickListener listener) {
        this.clickListener = listener;
    }
    // 模拟点击事件
    public void performClick() {
        System.out.println("按钮被点击了");
        if (clickListener != null) {
            clickListener.onClick(this);
        }
    }
}
// 按钮类
public class Button extends View {
    private String text;
    public Button(String text) {
        this.text = text;
    }
    public String getText() {
        return text;
    }
}
// 使用示例
public class Main {
    public static void main(String[] args) {
        Button button = new Button("点击我");
        // 设置点击回调
        button.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                Button btn = (Button) v;
                System.out.println("按钮 \"" + btn.getText() + "\" 被点击了");
            }
        });
        // 模拟点击
        button.performClick();
        // Lambda表达式方式
        Button button2 = new Button("另一个按钮");
        button2.setOnClickListener(v -> {
            Button btn = (Button) v;
            System.out.println("Lambda方式: 按钮 \"" + btn.getText() + "\" 被点击了");
        });
        button2.performClick();
    }
}

排序完成回调

// 排序回调接口
public interface SortCallback {
    void onSortComplete(int[] sortedArray);
    void onProgress(int percent);
}
// 排序器类
public class ArraySorter {
    public void sortAsync(int[] array, SortCallback callback) {
        new Thread(() -> {
            int[] temp = array.clone();
            // 冒泡排序（带进度反馈）
            for (int i = 0; i < temp.length - 1; i++) {
                for (int j = 0; j < temp.length - 1 - i; j++) {
                    if (temp[j] > temp[j + 1]) {
                        int swap = temp[j];
                        temp[j] = temp[j + 1];
                        temp[j + 1] = swap;
                    }
                }
                // 报告进度
                int progress = (i + 1) * 100 / (temp.length - 1);
                if (callback != null) {
                    callback.onProgress(progress);
                }
            }
            // 排序完成
            if (callback != null) {
                callback.onSortComplete(temp);
            }
        }).start();
    }
}
// 使用示例
public class Main {
    public static void main(String[] args) {
        int[] numbers = {64, 34, 25, 12, 22, 11, 90};
        ArraySorter sorter = new ArraySorter();
        sorter.sortAsync(numbers, new SortCallback() {
            @Override
            public void onSortComplete(int[] sortedArray) {
                System.out.print("排序完成: ");
                for (int num : sortedArray) {
                    System.out.print(num + " ");
                }
                System.out.println();
            }
            @Override
            public void onProgress(int percent) {
                System.out.println("排序进度: " + percent + "%");
            }
        });
        System.out.println("主线程继续执行其他任务...");
    }
}