Java回调机制解析

Java回调机制解析
         回调机制的概念可用一句话总结：A对象调用B对象的C方法时，C方法内可调用A对象中的D方法，这个过程就是所谓的回调机制。

         示例代码：

A方法

public class A {

         public voidD(){

                   System.out.println("调用A对象的D方法");

         }

         public static void main(String[] args){

                   B b= new B();

                   A a= new A();

                   b.C(a);

         }

}

B方法

public class B {

         public voidC(A a){

                   System.out.println("调用B对象的C方法");

                   a.D();

         }

}

运行：

这样说来回调机制其实也不是什么高级的东西，因为B对象的C方法还是需要A类型的参数的，然后再调用该A类型参数的D方法，不是什么未知的内容。但是这种思路在多线程的时候起了很大的作用，比方说这么一个情景：

A打电话给B，但是B一时在忙，没办法接电话，在B没有接电话的这段时间，电话不停地在响铃（这是一个A开启的线程），当B接起电话时，电话才会停止响动（即B关闭A开启的线程），但是只有A中的办法才能关闭A的电话响铃，所以B必须调用A的方法才能关闭电话，程序如下：

PhoneBegin类

package example01;

 

/**

 * @author Blank

 *

 */

public
class PhoneBegin implementsCallback,Runnable{

         privateint
status= 1;

         publicstatic
voidmain(String[] args){

                   PhoneBegin begin = new PhoneBegin();

                   //A开始打电话

                   begin.givePhone();

                   Remote remote = new Remote();

                   //B过了10秒才接起电话

                   try{

                            Thread.sleep(10000);

                   } catch(InterruptedException e) {

                           
// TODO Auto-generated catch block

                            e.printStackTrace();

                   }

                   remote.PickUpPhone(begin);

         }

         publicvoid givePhone(){

                   //开始打电话，电话开始响铃，这是一个新的线程

                   System.out.println("开始打电话");

                   Thread thread = new Thread(this);

                   thread.start();

                  

                  

                  

         }

        

         /*A类中关闭响铃的方法*/

         publicvoid execute(String name){

                   System.out.println("hello，This is "+name);

                   this.status=0;

         }

         publicvoid run(){

                   //电话每隔1秒响铃一次，并且在执行A类的execute方法之前是无法停止响铃的

                   while(true){

                            try {

                                     Thread.sleep(1000);

                            } catch (InterruptedException e) {

                                    
// TODO Auto-generated catch block

                                     e.printStackTrace();

                            }

                           

                            if(this.status==0){

                                     break;

                            }else{

                                     System.out.println("铃铃铃");

                            }

                   }

                  

                  

         }

        

}

CallBack接口

package example01;

 

public
interface Callback {

         publicvoid execute(String name);

}

Remote类

package example01;

 

/**

 * @author Blank

 *

 */

public
class Remote {

         publicvoid PickUpPhone(Callback call){

                  

                   //回调A关闭铃声的方法

                   call.execute("Bob");

         }

}

 

运行结果：



由上面例子可以看出回调机制的好处，即可以在一个线程中影响另一个线程的运行。