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("释放连接...");  
         }