可是问题来了，对于上面这个例子来说，看不出用回调有什么好处，直接在调用方法不可以了，为什么要使用回调呢？
　　事实上，很多需要进行回调的操作是比较费时的，被调用者进行费时操作，然后操作完之后将结果回调给调用者。看这样一个例子：

 

//模拟Spring中HibernateTemplate回调机制的代码
interface CallBack{
public void doCRUD();
}
public class HibernateTemplate {
public void execute(CallBack action){
getConnection();
action.doCRUD();
releaseConnection();
}
public void add(){
execute(new CallBack(){
public void doCRUD(){
System.out.println("执行add操作...");
}
});
}
public void getConnection(){
System.out.println("获得连接...");
}
public void releaseConnection(){
System.out.println("释放连接...");
}
}

　　可能上面这个例子你不能一眼看出个所以然来，因为其实这里A是作为一个内部匿名类存在的。好，不要急，让我们把这个例子来重构一下：

 

interface CallBack{   //相当于接口InA
public void doCRUD();
}
public class A implements CallBack{//【背景1】
private B b;//【背景2】
public void doCRUD(){
System.out.println("执行add操作...");
}
public void add(){
b.execute(new A());//【you call me】
}
}
public class B{
public void execute(CallBack action){  //【背景3】
getConnection();
action.doCRUD();  //【i call you back】
releaseConnection();
}
public void getConnection(){
System.out.println("获得连接...");
}
public void releaseConnection(){
System.out.println("释放连接...");
}
}

　　好了，现在明白多了吧，完全可以转化为上面所说的回调使用方式的模板。
　　现在在来看看为什么要使用回调，取得连接getConnection();是费时操作，A希望由B来进行这个费时的操作，执行完了之后通知A即可（即所谓的i call you back）。这是这里使用回调的原因。
　　在网上看到了一个比喻，觉得很形象，这里借用一下：
　　你有一个复杂的问题解决不了，打电话给你的同学，你的同学说可以解决这个问题，但是需要一些时间，那么你不可能一直拿着电话在那里等，你会把你的电话号码告诉他，让他解决之后打电话通知你。回调是体现在你的同学又反过来拨打你的号码。
　　结合到前面所分析的，你打电话给你同学是【you call me】，你同学解决完之后打电话给你是【i call you back】。
　　怎么样，现在理解了吧？
　　---------------------------------以下为更新----------------------------------
　　看了有些朋友的回帖，我又思考了一下，感觉自己之前对回调作用的理解的确存在偏差。
　　下面把自己整理之后的想法共享一下，如果有错误希望指出！多谢！
　　先说上面这段代码，本来完全可以用模板模式来进行实现：

 

public abstract class B{
public void execute(){
getConnection();
doCRUD();
releaseConnection();
}
public abstract void doCRUD();
public void getConnection(){
System.out.println("获得连接...");
}
public void releaseConnection(){
System.out.println("释放连接...");
}
}
public class A extends B{
public void doCRUD(){
System.out.println("执行add操作...");
}
public void add(){
doCRUD();
}
}
public class C extends B{
public void doCRUD(){
System.out.println("执行delete操作...");
}
public void delete(){
doCRUD();
}
}
如果改为回调实现是这样的：
interface CallBack{
public void doCRUD();
}
public class HibernateTemplate {
public void execute(CallBack action){
getConnection();
action.doCRUD();
releaseConnection();
}
public void add(){
execute(new CallBack(){
public void doCRUD(){
System.out.println("执行add操作...");
}
});
}
public void delete(){
execute(new CallBack(){
public void doCRUD(){
System.out.println("执行delete操作...");
}
});
}
public void getConnection(){
System.out.println("获得连接...");
}
public void releaseConnection(){
System.out.println("释放连接...");
}
}

　　可见摒弃了继承抽象类方式的回调方式更加简便灵活。不需要为了实现抽象方法而总是继承抽象类，而是只需要通过回调来增加一个方法即可，更加的直观简洁灵活。这算是回调的好处之一。