巧用生活场景，理解 Java 中的回调机制

背景案例：

夏日午后，你到超市买东西，刚好你要的东西没货了，于是你把电话号码留给店员。
过几天超市进货，店员打电话通知你有货了，你接到电话后去超市取到了自己要的货。

Java 编程语言中有一个很棒的概念：回调。大多数人都知道回调这个概念，但很少有人能完全说出其中的内涵。那回调到底是个什么东西呢？

上边这个案例，从生活场景的角度很好的诠释了 Java 的回调机制，其中的场景与涉及到的专业术语对应如下：

你的电话号码 →→ 回调方法
你把电话留给店员 →→ 注册回调方法
超市后来有货了 →→ 触发了回调关联的事件
店员给你打电话 →→ 调用回调方法
你到店里去取货 →→ 响应回调事件

通俗地讲，所谓回调，就是：

在 A 类（你）中调用 B 类（超市）中的某个方法 c（出货），然后 B 类中反过来调用 A 类中的方法 d（打电话），d 这个方法就叫回调方法。最终，A 类通过回调方法拿到了自己想要的东西。

这样说，你可能大概理解一些了，但我敢肯定，你还是有点晕晕的，其实这也正常，需要循序渐进的去学习和理解。不过没关系，下面来个更经典的解释：

条件 ①：Class A 实现接口 Callback（重写接口 Callback 的方法 d）
条件 ②：Class A 中包含一个 Class B 的引用 b
条件 ③：Class B 中有一个参数为 callback 的方法 c(Callback callback)

A 的对象 a 通过所持有的 b 调用 B 中的方法 c(Callback callback) →→ A 类调用 B 类的方法 c
然后 b 就可以在 c(Callback callback) 方法中通过 callback 调用 A 的方法 d →→ B 类调用 A 类的方法 d

讲了这么多，索性就再通过一个生活场景的例子，来真实的体验一下回调机制吧。

场景：

有一天小王遇到一个很难的问题，问题是“1 + 1 = ?”，于是打电话问小李，小李一下子也蒙圈了，就跟小王说：“等我处理完手上的事儿，就去想想答案，想出来给你回信儿。”
此时，小王当然不会傻傻的拿着电话去等小李的答案吧，于是小王就对小李说：“我正好要陪媳妇儿逛个街，你知道答案就打我电话告诉我。”
于是小王挂了电话，去陪媳妇儿逛街了。
过了一个小时，小李终于算出答案，于是打了小王的电话，告诉他：答案是2。

表现在代码上则如下：

/**
 * 这是一个回调接口
 *
 * @author Jerry
 */
public interface Callback {
    /**
     * 这个是小李知道答案，想要通知小王时要调用的方法，也就是回调方法
     *
     * @param result 是答案
     */
    public void solve(String result);
}

首先出场的，是传说中的小王：

/**
 * 这个是小王
 *
 * @author Jerry
 * 实现了回调接口 Callback，同时重写接口中的方法 solve（相当于：条件 ①）
 */
public class XiaoWang implements Callback {
    /**
     * 小李对象的引用（相当于：条件 ②）
     */
    private XiaoLi mXiaoLi;

    /**
     * 小王的构造方法，持有小李的引用
     *
     * @param xiaoLi
     */
    public XiaoWang(XiaoLi xiaoLi) {
        this.mXiaoLi = xiaoLi;
    }

    /**
     * 小王通过这个方法去问小李问题
     *
     * @param question 小王要问的问题（1 + 1 = ?）
     */
    public void askQuestion(final String question) {
        System.out.println("小王打电话问小李问题→→" + question);
        /**
         * 这里开启一个线程，异步请求
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                /**
                 * XiaoWang.this
                 * 在匿名内部类的方法中，要指定某个嵌套层次外围类的“this”引用时，
                 * 使用“外围类名.this”语法
                 *
                 * 小王调用小李的方法，并在这里注册回调接口 
                 * 相当于 A 类调用 B 类的方法 c 
                 */
                mXiaoLi.executeMessage(XiaoWang.this, question);
            }
        }).start();

        // 小王问完小李问题，挂掉电话就陪媳妇儿逛街去了  
        hangout();
    }

    /**
     * 问完问题逛街去喽
     */
    public void hangout() {
        System.out.println("我要陪媳妇儿逛街去了");
    }

    /**
     * 重写 Callback 接口中的方法（小王的回调方法）
     * 小李知道答案后要调用此方法告诉小王，通过传参 result 将答案告诉小王
     */
    @Override
    public void solve(String result) {
        System.out.println("小李告诉小王的答案是→→" + result);
    }
}

接下来，该小李子出场了：

public class XiaoLi {
    /**
     * 小李处理信息的方法
     * B 类中有参数为 Callback callback 的方法 d（相当于：条件 ③）
     *
     * @param callback 接口实例
     * @param question 小王问的问题
     */
    public void executeMessage(Callback callback, String question) {
        System.out.println("小王问的问题→→" + question);

        // 模拟小李处理自己的事情需要很长时间
        for (int i = 0; i < 10000; i++) {

        }

        /**
         * 小李处理完自己的事儿后，想到了答案：2
         */
        String result = "答案是2";

        /**
         * 于是打电话给小王，调用小王的方法，同时将答案传送给小王
         * 相当于 B 类反过来调用 A 的方法 d
         */
        callback.solve(result);
    }
}

最后再写个测试类，检验一下。是骡子是马，总得拉出来溜溜：

/**
 * 测试类
 *
 * @author Jerry
 */
public class Test {
    public static void main(String[] args) {
        /**
         *  先 new 一个小李
         */
        XiaoLi mXiaoLi = new XiaoLi();

        /**
         * 再 new 一个小王，同时持有小李
         */
        XiaoWang mXiaoWang = new XiaoWang(mXiaoLi);

        /**
         * 小王问小李问题
         */
        mXiaoWang.askQuestion("1 + 1 = ?");
    }
}

下面，在 Command Line 中跑一下代码，见证奇迹的时刻到了：

测试结果

至此，借用生活场景，已经循序渐进的把 Java 中的回调机制讲解完了，相信此刻的你更加理解了吧。

接下来，就需要多思考，并且多加练习，在真实业务场景中多去运用，相信你会游刃有余的。