回调（callback）

http://www.importnew.com/19301.html

回调的核心就是回调方将本身即this传递给调用方，这样调用方就可以在调用完毕之后告诉回调方它想要知道的信息。

1、什么是回调

软件模块之间总是存在一定的接口，从调用方式上，可以把他们分为三类:同步调用、回调和异步调用。

(1)同步调用:

同步调用是最基本并且最简单的一种调用方式，类A的方法a()调用类B的方法b(),一直等待b()方法执行完毕，a()方法再继续往下走。这种调用方式适用于方法b()执行时间不长的情况，因为b()方法执行时间一长或者直接阻塞的话，a()方法的余下代码是无法执行下去的，这样会造成整个流程的阻塞。

(2)异步调用:

是一种类似消息或事件的机制，是为了解决同步调用可能出现阻塞，导致整个流程卡住而产生的一种调用方式。类A的方法a()通过新起线程的方式调用类B的方法b(),代码接着直接往下执行，这样无论方法b()执行时间多久，都不会阻塞方法a()的执行。但是这种方式，由于方法a()不等待方法b()执行完成，在方法a()需要方法b()执行结果的情况下(视具体业务而定，有些业务比如启动异步线程发个微信通知、刷新一个缓存这种就没有必要)，必须通过一定的方法对方法b()的执行结果进行监听。在Java中，可以使用Future+Callable的方式做到这一点。

(3)回调：

最后是回调，回调的思想是:

• 类A的a()方法调用了类B的b()方法
• 类B的b方法执行完毕主动调用类A的callback()方法

这样一种调用方式组成了上图，也就是一种双向的调用方式

回调函数是一个函数或过程，不过它是一个由调用方自己实现，供被调用方使用的特殊函数。

在面向对象的语言中，回调则是通过接口或抽象类来实现的，我们把实现这种接口的类称为回调类，回调类的对象称为回调对象。

例子

开始之前。先想象一个场景:幼稚园的小朋友刚刚学习了10以内的加法。

第一章.故事的缘起

幼师在黑板上写一个式子 “1+1=”，由小明来填空
由于已经学习了10以内的加法，小明同学可以完全靠自己来计算这个题目，模拟该过程的代码如下:

public class Student
{
	private String name=null;
	public Student(String name)
	{
		this.name=name;
	}
	public void setName(String name)
	{
		this.name=name;
	}
	private int calcADD(int a,int b)
	{
		return a+b;
	}
	public void fillBlank(int a,int b)
	{
		int result=calcADD(a,b);
		System.out.println(name+"心算:"+a+"+"+b+"="+result);
	}
}

小明同学在填空(fillBlank)的时候，直接心算(clacADD)了一下，得出结果是2，并将结果写在空格里。测试代码如下:

public class Test
{
	public static void main(String[] args)
	{
		int a=1;
		int b=1;
		Student s=new Student("小明");
		s.fillBlank(a,b);
	}
}

运行结果如下

小明心算:1+1=2

该过程完全由Student类的实例对象单独完成，并未涉及回调机制。

第二章.幼师的找茬

课间，幼师突发奇想在黑板上写了"168+291=",让小明完成，然后回办公室去了。
这时候小明明显不能再像上面那样靠心算来完成了，正在懵逼的时候，班上的小红同学递过来一个只能计算加法的计算机，而小明同学恰好知道怎么用计算器，于是通过计算器计算得到结果并完成了填空。
计算器的代码为：

public class Calculator
{
	public int add(int a,int b)
	{
		return a+b;
	}
}

修改Student类，添加使用计算器的方法：

public class Student
{
	private String name=null;
	public Student(String name)
	{
		this.name=name;
	}
	public void setName(String name)
	{
		this.name=name;
	}
	private int calcADD(int a,int b)
	{
		return a+b;
	}
	private int useCalculator(int a,int b)
	{
		return new Calculator().add(a,b);
	}
	public void fillBlank(int a,int b)
	{
		int result=useCalculator(a,b);
		System.out.println(name+"使用计算器:"+a+"+"+b+"="+result);
	}
}

测试代码如下:

public class Test
{
	public static void main(String[] args)
	{
		int a=168;
		int b=291;
		Student s=new Student("小明");
		s.fillBlank(a,b);
	}
}

运行结果如下:

小明使用计算器:168+291=459

该过程中仍未涉及到回调机制，但是小明的部分工作已经实现了转移，由计算器来协助实现。

第三章.幼师回来了

发现小明完成了3位数的加法，老师觉得小明很聪明，是个可塑之才。于是又在黑板上写下了"26549+16387=",让小明上课之前完成填空，然后又回办公室了。
小明看着小红再一次递上来的计算机，心生一计：让小红代劳。
小明告诉小红题目是"26549+16487="，然后指出填写结果的具体位置，然后就出去快乐的玩耍了。
这里，不把小红单独实现出来，而是把这个只能算加法的计算器和小红看成一个整体，一个会算结果还会填空的超级计算器。折这个超级计算器需要传的参数是两个加数和要填空的位置，而这些内容需要小明提前告知，也就是小明要把自己的一部分方法暴露给小红，最简单的方法就是把自己的引用和两个加数一块告诉小红。
因此，超级计算器的add方法应该包含两个操作数和小明自身的引用，代码如下:

public class SuperCalculator
{
	public void add(int a,int b,Student xiaoming)
	{
		int result=a+b;
		xiaoming.fillBlank(a,b,result);
	}
}

小明这边现在已经不需要心算，也不需要使用计算器，因此只需要有一个方法可以向小红寻求帮助就行了，代码如下:

public class Student
{
	private String name=null;
	public Student(String name)
	{
		this.name=name;
	}
	public void setName(String name)
	{
		this.name=name;
	}
	public void callHelp(int a,int b)
	{
		new SuperCalculator().add(a,b,this);
	}
	public void fillBlank(int a,int b,int result)
	{
		System.out.println(name+"求助小红计算:"+a+"+"+b+"="+result);
	}
}

测试代码如下:

public class Test
{
	public static void main(String[] args)
	{
		int a=26549;
		int b=16487;
		Student s=new Student("小明");
		s.callHelp(a,b);
	}
}

运行结果为:

小明求助小红计算:26549+16487=43036

执行流程为：小明通过自身的callHelp方法调用了小红(new SuperCalculator())的add方法，在调用的时候将自身的引用(this)当作参数一并传入，小红在使用计算器得出结果之后，回调了小明的fillBlank方法，将结果填在了黑板的空格上。

到这里，回调功能就正式登场了，小明的fillBlank方法就是我们常说的回调函数。

通过这种方式，可以明显的看出，对于完成老师的填空题这个问题上，小明已经不需要等待到加法做完且结果填写在黑板上才能去跟小伙伴撒欢了，填空这个工作由超级计算器小红来做了。回调的优势已经开始体现了。

第4章.门口的婆婆

幼稚园的门口有一个头发花白的老婆婆，每天风雨无阻在那里摆着地摊卖一些快过期的垃圾食品。由于年纪大了，脑子有些糊涂，经常算不清楚自己挣了多少钱。有一天，她无意间听到了小明跟小伙伴们吹嘘自己如何在小红的帮助下与幼师斗智斗勇。于是，婆婆决定找到小红牌超级计算器来做自己的小帮手，并提供一包卫龙辣条作为报酬。小红经不住诱惑，答应了。

回看一下上一章的代码，我们发现小红牌超级计算器的add方法需要的参数是两个整型变量和一个Student对象，但是老婆婆她不是学生，是个小商贩啊，这里肯定要做修改。这种情况下，我们很自然的会想到继承和多态。如果让小明这个学生和老婆婆这个小商贩从一个父类进行继承，那么我们只需要给小红牌超级计算器传入一个父类的引用就可以啦。

不过，实际使用中，考虑到java的单继承，以及不希望把自身太多东西暴漏给别人，这里使用从接口继承的方式配合内部类来做。

换句话说，小红希望以后继续向班里的小朋友们提供计算服务，同时还能向老婆婆提供算账服务，甚至以后能够拓展其他人的业务，于是她向所有的顾客约定了一个办法，用于统一的处理，也就是自己需要的操作数和做完计算之后应该怎么做。这个统一的方法，小红做成了一个接口，提供给了大家，代码如下：

public interface doJob
{
	public void fillBlank(int a,int b,int result);
}

因为灵感来自帮小明填空，因此小红保留了初心，把所有业务当做填空(fillBlank)来做。

同时，小红修改了自己的计算器，使其可以同时处理不同的实现了doJob接口的人，代码如下：

public class SuperCalulator
{
	public void add(int a,int b doJob customer)
	{
		int result=a+b;
		customer.fillBlank(a,b,result);
	}
}

小明和老婆婆拿到这个接口之后，只要实现了这个接口，就相当于按照统一的模式告诉小红得到结果之后的处理办法，按照之前说的使用内部类来做，代码如下:
小明的:

public class Student
{
	private String name=null;
	public Student(String name)
	{
		this.name=name;
	}
	public class doHomeWork implements doJob
	{
		@Override
		public void fillBlank(int a,int b,int result)
		{
			System.out.println(name+"求助小红计算:"+a+"+"+b+"="+result);
		}
	}
	public void callHelp(int a,int b)
	{
		new SuperCalculator().add(a,b,new doHomeWork());
	}
}

老婆婆的：

public class Seller
{
	private String name=null;
	public Seller(String name)
	{
		this.name=name;
	}
	public setName(String name)
	{
		this.name=name;
	}
	public class doHomeWork implements doJob
	{
		@Override
		public void fillBlank(int a,int b,int result)
		{
			System.out.println(name+"求助小红算账:"+a+"+"+b+"="+result+"元"；)
		}
	}
	public void callHelp(int a,int b)
	{
		new SuperCalculator().add(a,b,new doHomeWork());
	}
}

测试程序如下：

public class Test
{
	public static void main(String[] args)
	{
		int a=56;
		int b=31;
		int c=26497;
		int d=11256;
		Student s1=new Student("小明")；
		Seller s2=new Seller("老婆婆")；
		
		s1.callHelp(a,b);
		s2.callHelp(c,d);
	}
}

运行结果如下:

小明求助小红计算:56+31=87
老婆婆求助小红算账:26497+11256=37753元