这个术语会经常让我们单纯地认为回调就像打电话一样只是你我之间双方的互相呼应，可能就因为这样，所以有很多关于回调的文章都会出现 “If you call me, I will call you back.” 或者是 “If you call me, I will call back.” 。但这样来说明是有一定的误导性的，只能说双方相互呼应只是回调的一种特殊情况罢了。

在计算机编程中，一小段可执行的代码作为一个参数传递到另一段代码，并且它将会在某个合适的时间回调（执行），这就是 回调（callback） 。

或许你会注意到定义里所提到的： 某个合适的时间 ，其实这个指的是某些“事件”的发生，而这个“事件”可能是条件判定、函数调用、按钮点击事件或者是计时器计时等等。

这是对回调广义上的描述，也是最本质的描述。但是我们在讨论关于回调的时候都经常将其称为回调函数。这是因为在我们使用各种编程语言再加以运用回调技术的时候，那段进行回调的代码基本上都是函数。不同的语言，实现回调的方式也不一样，可以用以下几种技术实现回调：子程序、lambda表达式、块、函数指针。

那现在我们就来用自己的话来描述一下回调函数：

这时，想必大家都对什么是回调，什么是回调函数都有了一个印象比较深刻的初步认识。这几句简洁易懂的描述的就是它们的本质， 但是你是否发现这些定义都没有描述到回调的 “回”这一个字的意思？

上面这个图来源于维基百科。这个图很形象地描述了回调中“回”字的意思。

我们通常都在使用别人已经编写好的库为自己所要做的应用进行编程。如上图所示，回调函数和应用的主函数处在同一个抽象层（高层抽象），所要做的应用有什么样的需求，我们就编写完成对应需求的回调函数传递给底层抽象，因此，回调函数和应用的主函数处于同一个抽象层这点是很自然而然的。

在高层抽象向底层抽象传递回调函数的前提下，这个图所描述的过程：

综上所述：回调的“回”的意思就是程序执行流程从底层回到高层。

现在还是来看一个现实中打电话的例子：

老板和员工的情景：老板给员工分配一个任务，并且老板告诉员工：“这个任务完成后，你就打电话给我，并且向我说明一下解决方案”。分配完任务后，老板外出或者做其他事去了。在某个时刻，员工终于把那个任务完成了，他就打电话给老板报告一下任务完成的情况以及解决方案。

在动手写代码之前，我们必须把这个情景中几个关键的动作搞清楚：

按照上面关于回调函数的描述，从这几个动作我们可以得出：

老板和员工整个情景过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Company {
    public static final String EASY_TASK = "这是一个简单的任务";
    public static final String DIFFICULT_TASK = "这是一个棘手的任务";
    public static final String VERY_DIFFICULT_TASK = "这是一个非常棘手的任务";

    public static void main(String[] args) {
        // 老板
        Boss boss = new Boss();
        // 打工仔
        Worker worker = new Worker();
        // 老板给属下员工分配任务
        boss.assign(worker, DIFFICULT_TASK);
        // 派遣完任务后, 老板做其他事情去了
        boss.doOtherThings();
    }
}

这个过程用代码模拟后看起来是不是很简单、很清晰？至于任务我就用常量作简化处理了，毕竟我们此处最关心的并不是这些。

再来看老板 Boss 的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Boss {
    private String telNumber = "1360****459";

    public void assign(final Worker worker, final String task) {
        System.out.println("---老板开始分配任务---");
        new Thread() {
            @Override
            public void run() {
                // 员工接受老板分配的任务, 并且接受老板吩咐任务完成后要做的事
                worker.accept(task, new OnTaskComplete() {
                    @Override
                    public void callBack(String solution) {
                        System.out.println("打电话给xxx: " + telNumber);
                        System.out.println("并且报告解决方案: " + solution);
                    }
                });
            }
        }.start();
        System.out.println("----老板分配任务完毕----");
    }

    public void doOtherThings() {
        System.out.println("-----老板去做其他事情了-----");
    }
}

此处，我们主要关注的肯定是 assign 分配任务的方法，这个方法接收2个参数，分别是员工 worker 和任务 task 。

既然老板分配任务给员工，员工 worker 肯定有一个方法接受任务并解决的。
员工着手任务时，不能让老板瞎等吧？所以要运用异步调用对这种情况进行模拟。这里便开辟一个新线程来调用员工 worker 接受任务的方法 accpet 。

方法 accept 同样是接收2个参数，任务 task 参数是必要的，而另一个参数是一个实现 OnTaskComplete 回调接口的匿名内部类对象。
在编程的角度上，这种行为就是上面分析所说的 注册回调函数（register callback function） 。
在情景的角度上，这就是对 “老板告诉员工任务完成后要做什么什么” 这个动作的模拟。

而匿名内部类里的 callBack 方法就是 回调方法（callback method）
该方法的具体实现就如同之前的情景： “老板给员工交代过，任务完成后打电话给老板并向他说明一下解决方案” 。
这里并没有具体的解决方案，因为这个解决方案需要员工在完成任务后回传才会有。

看完了老板 Boss ，接着肯定要看看打工仔 Worker 啦。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class Worker {
    public void accept(String task, OnTaskComplete followUpWork) {
        if (Company.EASY_TASK.equals(task)) {
            solve(task, 1, 3);
            if (followUpWork != null) {
                followUpWork.callBack("解决方案A");
            }
        } else if (Company.DIFFICULT_TASK.equals(task)) {
            solve(task, 4, 10);
            if (followUpWork != null) {
                followUpWork.callBack("解决方案B");
            }
        } else {
            System.out.println("该任务中的需求过于复杂，需要大家开会讨论");
        }
    }
	
    private void solve(String task, int bestTime, int worstTime) {
        int actualTime = (int) (Math.random() * (worstTime - bestTime + 1)) + bestTime;
        try {
            Thread.sleep(actualTime * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("解决任务( " + task + " )实际耗时: " + actualTime);
    }
}

Worker 中有2个方法，其中方法 solve 只是模拟员工耗时解决任务。而员工接受任务的 accept 方法才是重点。

方法 accept 接收2个参数，一个是任务 task ，另一个则是 OnTaskComplete 接口形式的参数 followUpWork ，用于调用回调方法 callBack 。
方法 accpet 很好地模拟了员工解决任务并且在之后打电话并报告解决方案这个动作。
员工根据任务的难易，估算一下解决任务的时间，并开始着手解决，这个耗时动作使用方法 solve 进行模拟。
当 solve 执行完毕后，即任务完成了，员工需要打电话给老板说明解决方案，这里就使用 followUpWork 回调 callBack 并 回传 解决方案。

最后，是回调接口的定义。这个就没什么可说了。接口这东西，只要你搞清楚需求，就很好去定义它了。

1
2
3

public interface OnTaskComplete {
    void callBack(String solution);
}

虽然这个情景整个过程乍看之下是比较简单，代码过程简洁清晰之余，还符合文章之前一直强调的回调或回调函数的定义，不过在我用Java代码合理地把它模拟出来还是费了不少功夫的（毕竟之前我也没怎么研究过回调，讲道理嘛）。其实我看过的某些博客文章解释回调，文字上是挺清晰的，但是一旦看代码我就卡住了，总觉得代码对情景模拟得不够自然，大多数都是由于命名不怎么好而导致我有这种感觉（代码的命名很重要，命名不好，别人或自己看起来就纠结了）。

而使用回调的好处，就如《Thinking In Java》里所说的： 回调的价值在于它的灵活性——可以在运行时动态地决定需要调用什么方法 。

以上就是我对回调的一些总结和见解，希望这些能够对大家有所帮助。有些地方可能有误，如果你有不同的看法，可以提出来，3Q。