对于技术问题，会用是一回事，理解这个技术问题的来龙去脉、设计者当初为什么要设计这个功能、这个技术问题有哪些优势、适用哪些场景又是另外回事了。

前者照猫画虎得其形，后者形神兼备得其意，这也是所谓青铜与王者的区别。

会使用、又能理解已经不易，如果还能表达出来，讲所有人都能看明白就更不容易了。

在软件开发这个行业，回调函数是最常见的功能。在图形界面开发的时候，每一个按钮的点击事件都会用到回调函数。

  • 什么是回调函数？
  • 为什么要用回调函数？
  • 在java中，为什么要用接口来实现回调函数？

这是要弄明白的几个问题！

什么是函数调用？

在弄清楚什么是回调函数之前，先要明白什么函数调用。“调用”的英语叫“call”，翻译过来也叫“打电话”。

打电话无非是沟通、协调、安排一些事情，或者还要得到自己想要的结果。

编程就是对现实的模拟和抽象，一定要理解这句话，下面我们就模拟一下。

我打电话（call）给老婆，问晚上要买点什么菜回家，老婆说买点五花肉回来晚上做回锅肉。我得到了想要的结果，这说明我调用这个函数得到了想要的返回值。

模拟代码：

  1.  public String callWife(String 什么菜){
  2.      //一顿沟通，自行脑补
  3.      return "五花肉";
  4.  }

我给孩子打电话，叮嘱他要完成家庭作业之后才能看电视。这次函数调用没有返回值，就像在函数体里面写了一句”我想你”一样。

模拟代码：

  1.  public void callBaby(){
  2.      System.out.println("I miss you");
  3.  }

这些都很好理解，可如果一个电话不能达到自己的目的呢？

我给朋友打电话，问什么时候能约一下其它几个朋友一起吃个饭，他说要先给他们沟通一下什么时候有时间，沟通好了再通知我，具体需要沟通多久也不确定。

这个问题就不是一个电话（一次函数调用）就能解决问题了，需要再打电话回来（callback）才能达到自己的目的。

但此处要记住几个关键点：

  1. 我打电话给朋友，相当于我调用了函数callFriend()
  2. 我接到朋友的通知，相当于朋友调用了我的一个函数。
  3. 我是这次交互的主体。

什么是回调函数？

在英语中，callback是回电话的意思，而在开发中callback叫回调函数，其实就是回电话的意思，callback这一个单词已经把“回调”的神表达出来了，作为开发者，完全可以按回电话的场景来理解回调函数。

仔细咂摸一下，回电话这个场景与回调函数的使用场景何其像啊！点击一个按钮或链接，然后等待数据的返回和界面的刷新，具体等待多久也不确定，可能0.1秒就响应了，也可能5秒之后才响应，总之，响应时间是不确定的，不能让人一直等着，这不就像等一个回电话的过程吗？

下面我用实际代码模拟上面的沟通过程

这个过程涉及到我和朋友两个实体类，Me类代表我，Friend类代表我的朋友。

因为我要打电话给朋友和接朋友电话通知，所以Me类有三个功能，也叫行为：给朋友打电话，我们用callFriend(Friend)来表示；接到朋友的通知，我们用noticeMe()函数来表示；在给朋友打电话和接朋友电话通知之间的这一段时间，我在忙其它的事情，我们用doOtherthing()函数来表示。

朋友要先给其他小伙伴约时间然后给我打电话，所以Friend类也有个函数order()定义他和其它小伙伴的预约过程，约好时间之后又要给我回电话，所以还要有个参数为Me的对象。

代码如下，这些代码是可以直接运行的，并且用数字对程序的运行顺序做了标记。

Me.java的代码

  1.  public class Me {
  3.      //    给朋友打电话
  4.      public void callFriend(Friend friend) throws InterruptedException {
  5.          System.out.println("1、我打电话给朋友，让他去约时间");
  6.          friend.order(this);
  7.          doOtherThing();
  8.      }
  10.      //    通知我
  11.      public void noticeMe() {
  12.          System.out.println("6、我收到了朋友的通知");
  13.      }
  15.      //    忙其它的事情去了
  16.      public void doOtherThing() {
  17.          System.out.println("3、我去忙其它的事情...");
  18.      }
  19.  }

Friend.java

  1.  public class Friend {
  3.      //和其他小伙伴约好时间后通知我
  4.      public void order(final Me me) throws InterruptedException {
  5.          System.out.println("2、朋友接到电话说：我现在就和其他小伙伴约时间，请稍等...");
  7.          new Thread(new Runnable() {
  8.              public void run() {
  9.                  try {
  10.                      System.out.println("4、朋友正在电话联系中....");
  11.                      sleep(5000);
  12.                      System.out.println("5、朋友已经约好了，准备给我回电话");
  13.                      me.noticeMe();
  14.                  } catch (InterruptedException e) {
  15.                      e.printStackTrace();
  16.                  }
  17.              }
  18.          }).start();
  19.      }
  20.  }

对这段代码加以说明：

  • 函数中使用线程是为了模拟朋友的沟通过程，在实际应用中多为耗时的操作。
  • “朋友”沟通过程与“我”忙其它事情是并行的，“我”并没有等待他。

最后，写主程序

  1.  //测试回调的主类
  2.  public class Main {
  4.      public static void main(String[] args) throws InterruptedException {
  5.  //        创建我和朋友的对象
  6.          Me me = new Me();
  7.          Friend friend = new Friend();
  8.  //        给朋友打电话
  9.          me.callFriend(friend);
  10.      }
  11.  }

看运行结果

JAVA的回调函数 - 图1

从结果中可以看出，我联系朋友之后就忙其它事情了，朋友接到电话之后就去沟通，我也不知道他会沟通多久，朋友在沟通完之后通知我，就完事了。

从主程序可以看出，只有我调用了callFriend()，朋友怎么沟通、怎么回电话，我都不关注，他只需要持有“我”对象的引用就行了，需要通知我时，就通过引用调用noticeMe()。

有主动调用过程，也有callBack的过程，这个实例已经展示了回调的全部了，但显然并不完美

试想以下场景：

  • 老板安排给员工一个任务，要求完成工作后通知老板
  • 父母安排你飞机落地后，给他们报个平安。

生活中这样的场景非常多，在实际项目中也是，但是在项目中，我们在每个类中定义一个类似noticeMe()这样的类就不高明了，因为违背了“复用”的编程原则，虽然实现了回调的功能，但并不是真正意义上的回调函数。

所以我们可以对“通知”这一行为进一步抽象，对行为抽象当然要使用接口。

具体代码如下:

  1.  /*定义接收通知接口，所有参与者可实现此接口以接收通知*/
  2.  public interface CallBack {
  3.      //参与者可以实现接收通知的细节
  4.      public void receiveNotice(String friendName);
  5.  }

这里有个参数friendName，朋友通知我的时候，可以通过这个参数传递一些信息，比如他的名字。

Me.java实现这个接口后的代码

  1.  public class Me implements CallBack{
  3.      //    给朋友打电话
  4.      public void callFriend(Friend friend) throws InterruptedException {
  5.          System.out.println("1、我打电话给朋友，让他去约时间");
  6.          friend.order(this);
  7.          doOtherThing();
  8.      }
  11.  //    public void noticeMe() {
  12.  //
  13.  //    }
  15.      //    忙其它的事情去了
  16.      public void doOtherThing() {
  17.          System.out.println("3、我去忙其它的事情...");
  18.      }
  19.      //    通知我
  20.      public void receiveNotice(String friendName) {
  21.          System.out.println("6、我收到了朋友 -"+friendName+ "- 的通知");
  22.      }
  23.  }

Friend.java做相应的修改后：

  1.  public class Friend {
  3.      //和其他小伙伴约好时间后通知我
  4.      public void order(final CallBack callBack) {
  5.          System.out.println("2、朋友接到电话说：我现在就和其他小伙伴约时间，请稍等...");
  7.          new Thread(new Runnable() {
  8.              public void run() {
  9.                  try {
  10.                      System.out.println("4、朋友正在电话联系中....");
  11.                      sleep(5000);
  12.                      System.out.println("5、朋友已经约好了，准备给我回电话");
  13.                      callBack.receiveNotice("张三");
  14.                  } catch (InterruptedException e) {
  15.                      e.printStackTrace();
  16.                  }
  17.              }
  18.          }).start();
  19.      }
  20.  }

Main.java的代码不需要调整。

运行结果和前面基本是一致的，我只是增加了一个参数，大家也可以体会一个这个参数带来的便利。

JAVA的回调函数 - 图2

多了一个接口的定义，代码好像更多了。但在实际扩展当中却更方便了，比如说，老板要接收员工的通知，老板类实现这个接口就完事了；父母要等待孩子的通知，父母类实现这个接口就可以。换句话说，所有要扩展接收通知的类，只要实现这个接口就具备了接收通知的功能。

这样的好处是代码得到了复用，极大的方便了扩展。

通过接口来实现回调的功能，这才是真正意义上的回调函数。

android中的控件点击，都是用回调函数来实现的，比如Button，View.OnClickListener就是接口，只有一个onClick()函数，类似上面的receiveNotice()函数，只是此处用匿名内部类实现了这个接口。java虚拟机监听着按钮，只要按钮被点击，onClick()就会被调用，而上面的例子是我们在代码中调用的，实质并不区别。

  1.   button.setOnClickListener(new View.OnClickListener() {
  2.       public void onClick(View v) {
  3.           //点击后的具体实现
  4.       }
  5.   });

这就是我对回调函数的理解，也欢迎与大家就此问题进行交流。