java中的回调机制

**定义：**就是A类中调用B类中的某个方法C，然后B类中反过来调用A类中的方法D，D这个方法就叫回调方法。
举例：
小刚有个问题不会，然后打电话问小明，小明也不会，说思考一会回复给你，小刚挂了电话，等着太浪费时间了，于是自己就去玩了，等小明思考到答案，就回复小刚。
首先创建一个接口：

public interface CallBack {	
	//这个是小明知道结果之后要调用的函数，告诉小刚，即回调函数
	public void solve(String result);
}

创建小刚类：

    public class Gang implements CallBack {  
        private Ming ming;   
      
        public Gang(Ming ming){  
            this.ming = ming;  
        }  
        public Gang(){  
        } 
         
        /** 
         * 小刚通过这个方法去问小明的问题 
         * @param question  就是小刚要问的问题,1 + 1 = ? 
         */  
        public void askQuestion(final String question){  
      //这里用一个线程就是异步，同时也可以不异步，同步执行；主要看业务的需求
            new Thread(new Runnable() {  
                @Override  
                public void run() {  
                    /** 
                     * 小刚调用小明中的方法，在这里注册回调接口 
                     * 这就相当于A类调用B的方法C 
                     */  

                	ming.executeMessage(new CallBack(){
 						@Override
 						public void solve(String result) {
 							//在回调我的时候所执行的方法体
 							System.out.println("匿名内类"+result);  
 							
 						}}, question);
                	 
                //这个Gang类，实现了接口，***传递这个实体类（当前类的对象）***，就是多态了啊
                //    ming.executeMessage(Gang.this,question);          
                }  
            }).start();  
              
            //小明问完问题挂掉电话就去干其他的事情了，玩去了  
            play();  
        }  
      
        public void play(){  
            System.out.println("问完问题了，我准备第二种方式实现"); 
            
            //在主线程中第二次实现回调方法
            Ming ming2 = new Ming();
            ming2.setCallBack(new CallBack(){//我先注册一个接口，把回调的方法完成
				@Override
				public void solve(String result) {
				
					System.out.println("实现的===="+result);  
					
				}
     	 });
            ming2.doCallBack();//我在这个方法中决定回调啊
        }  
      
        /** 
         * 小明知道答案后调用此方法告诉小刚，就是所谓的小刚的回调方法 
         */  
        @Override  
        public void solve(String result) {  
            System.out.println("小明告诉小刚的答案是-->" + result);  
        }  
                  
    }  

建立小明类：

    public class Ming {  	
        public void executeMessage(CallBack callBack, String question){  
            System.out.println("小刚问的问题--->" + question);  
              
            //模拟小明办自己的事情需要很长时间  
            for(int i=0; i<2;i++){  
                  System.out.println("小明在思考");
            }  
              
            /** 
             * 小明思考完之后想到了答案是2 
             */  
            String result = "=====答案是2";     
            /** 
             * 于是就打电话告诉小刚，调用小刚中的方法 
             * 这就相当于B类反过来调用A的方法D 
             */  
          //这个solve就是接口回调的D，即接口中定义的方法         
            callBack.solve(result);                           
        }        
        public CallBack callBack = null;
        
        //第二种方式,,传递给我的是CallBack的接口实现类
        public void setCallBack(CallBack callBack){
        	this.callBack = callBack;
        }
        //执行接口回调
        public void doCallBack(){
        	callBack.solve("我是第二种实现的，结果是===2");
        }
          
    }  

测试类：

public class Test {  
    public static void main(String[]args){  
        /** 
         * new 一个小明
         */  
        Ming ming = new Ming();  
  
        /** 
         * new 一个小刚
         */  
        Gang gang = new Gang(ming);  
          
        /** 
         * 小刚问小明问题 
         */  
        gang.askQuestion("1 + 1 = ?");  
    }  
} 

结果：
问完问题了，我准备第二种方式实现======
小刚问的问题—>1 + 1 = ?
实现的我是第二种实现的，结果是=2
小明在思考
小明在思考
匿名内类===答案是2
关于我的一点想法：
定义一个接口，一个类实现这个接口，并在该类中注册上该接口（通过匿名内部类或者多态的形式），在另外的类中决定什么时候触发回调该接口。
参考：
http://blog.csdn.net/xiaanming/article/details/8703708/
本文的很多代码，借鉴该博客，同时添加了一些自己的想法和见解，如有误，烦请指出更正，谢谢。