Java回调是一种双向调用模式,什么意思呢,就是说,被调用方在被调用时也会调用对方,这就叫回调。“If you call me, i will call back”。
不理解?没关系,先看看这个可以说比较 经典的使用回调的方式:  
- class A实现接口InA ——背景1
- class A中包含一个class B的引用b ——背景2
- class B有一个参数为InA的方法test(InA a) ——背景3
- A的对象a调用B的方法传入自己,test(a) ——这一步相当于you call me
- 然后b就可以在test方法中调用InA的方法 ——这一步相当于i call you back
是不是清晰一点了?下面再来看一个完全符合这个方式模板的例子
(PS:这个例子来源于网络,由于这个例子表现的功能极度拉风,令我感觉想想出一个超越它的例子确实比较困难,所以直接搬过来)
//相当于接口InA
public interface BoomWTC{
  //获得拉登的决定Java实现Ping
  public benLaDengDecide();  
  // 执行轰炸世贸
  public void boom();
}  
//相当于class A
public class At$911 implements BoomWTC{//相当于【背景1】
  private boolean decide;
  private TerroristAttack ta;//相当于【背景2】  
  public At$911(){
    Date now=new Date();
    SimpleDateFormat myFmt1=new SimpleDateFormat("yy/MM/dd HH:mm");
    this.dicede= myFmt.format(dt).equals("01/09/11 09:44");
    this.ta=new TerroristAttack();
  }  
  //获得拉登的决定
  public boolean benLaDengDecide(){
    return decide;
  }  
  // 执行轰炸世贸
  public void boom(){
    ta.attack(new At$911);//class A调用class B的方法传入自己的对象,相当于【you call me】
  }
}  
//相当于class B
public class TerroristAttack{
  public TerroristAttack(){
  }  
  public attack(BoomWTC bmw){——这相当于【背景3】
    if(bmw.benLaDengDecide()){//class B在方法中回调class A的方法,相当于【i call you back】
     //let's go.........
    }
  }
}  
现在应该对回调有一点概念了吧。
可是问题来了,对于上面这个例子来说,看不出用回调有什么好处,直接在调用方法不就可以了,为什么要使用回调呢?
事实上,很多需要进行回调的操作是比较费时的,被调用者进行费时操作,然后操作完之后将结果回调给调用者。看这样一个例子:
//模拟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("释放连接..."); 
        } 
}
 
  
  
  
 
 
  
  
  
 