精华内容
下载资源
问答
  • Java 回调函数CallBack

    2019-01-19 23:14:40
    软件模块之间总是存在着一定接口,从调用方式上,可以把他们分为三类:同步调用、回调和异步调用。 同步调用:一种阻塞式调用调用方要等待对方执行完毕才返回,它是一种单向调用; 回调:一...

    欢迎使用Markdown编辑器

    本质是多态的应用。

    回调机制:回调机制是一种常见的设计模型,他把工作流内的某个功能,按照约定的接口暴露给外部使用者,为外部使用者提供数据,或要求外部使用者提供数据。

    java回调机制:

    软件模块之间总是存在着一定的接口,从调用方式上,可以把他们分为三类:同步调用、回调和异步调用。

    同步调用:一种阻塞式调用,调用方要等待对方执行完毕才返回,它是一种单向调用;

    回调:一种双向调用模式,也就是说,被调用方在接口被调用时也会调用对方的接口;

    异步调用:一种类似消息或事件的机制,不过它的调用方向刚好相反,接口的服务在收到某种讯息或发生某种事件时,会主动通知客户方(即调用客户方的接口)。

    回调和异步调用的关系非常紧密:使用回调来实现异步消息的注册,通过异步调用来实现消息的通知。

    回调函数就是自己写的一个函数,但是不能被显式的调用,而是把该函数的地址作为一个别的函数参数来引用,这样用来处理当一些事件发生时可以调用这个自己定义的回调函数,完成一些处理,回调函数大多只是自己定义一个名字而已,函数体大多是系统定义好的,它有一个结构,一般一个代回调函数的的函数都有一个参数是接你的回调名的,它把一些值传进回调函数(函数体包括参数是它预定好的,不能自己写,除非全部函数都是你写的),然后回调函数接受值,相应操作后将值返回到原函数体(它的父亲函数),最终让原函数返回一个值,我们经常在C++设计时通过使用回调函数可以使有些应用(如定时器事件回调处理、用回调函数记录某操作进度等)变得非常方便和符合逻辑,那么它的内在机制如何呢,怎么定义呢?它和其它函数(比如钩子函数)有何不同呢?这里结合自己的使用经历做一个简单的介绍。
    使用回调函数实际上就是在调用某个函数(通常是API函数)时,将自己的一个函数(这个函数为回调函数)的地址作为参数传递给那个函数。而那个函数在需要的时候,利用传递的地址调用回调函数,这时你可以利用这个机会在回调函数中处理消息或完成一定的操作。至于如何定义回调函数,跟具体使用的API函数有关,一般在帮助中有说明回调函数的参数和返回值等。C++中一般要求在回调函数前加CALLBACK(相当于FAR PASCAL),这主要是说明该函数的调用方式。

    来自 https://blog.csdn.net/guohengsheng3882/article/details/78831640

    package cn.pb.CallBack;
    
    public class Records_life_cycle {
    
    	Records_life_cycle(Animal animal) {
    		System.out.println("出生");
    		System.out.println("进食");
    		//爬行方式
    		
    		animal.run();
    		
    		System.out.println("捕食");
    		System.out.println("死亡");
    	}
    	
    	public static void main(String[] args) {
    		Records_life_cycle f_cat = new Records_life_cycle(new Cat());
    		
    		System.out.println("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*");
    		
    		Records_life_cycle f_dog= new Records_life_cycle(new Dog());
    		
    		System.out.println("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*");
    		
    		Records_life_cycle f_lizard = new Records_life_cycle(new lizard());
    	}
    }
    
    class Cat implements Animal{
    
    	@Override
    	public void run() {
    		// TODO 自动生成的方法存根
    		System.out.println("猫步");
    		
    	}
    	
    }
    
    class Dog implements Animal{
    
    	@Override
    	public void run() {
    		// TODO 自动生成的方法存根
    		System.out.println("奔跑");
    		
    	}
    	
    }
    
    class lizard implements Animal{
    
    	@Override
    	public void run() {
    		// TODO 自动生成的方法存根
    		System.out.println("爬行");
    		
    	}
    	
    }
    
    package cn.pb.CallBack;
    
    interface Animal {
    	void run();
    }
    
    

    在这里插入图片描述
    结果:
    出生
    进食
    猫步
    捕食
    死亡
    --------------------*
    出生
    进食
    奔跑
    捕食
    死亡
    --------------------*
    出生
    进食
    爬行
    捕食
    死亡

    展开全文
  • Java回调函数callback接口

    千次阅读 2016-01-07 08:45:33
    资料一: 首先说说什么叫回调...在调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃。  这样的解释似乎还是比较难懂,这里举个简 单的例子:  程序员

    资料一:

    首先说说什么叫回调函数?

        在WINDOWS中,程序员想让系统DLL调用自己编写的一个方法,于是利用DLL当中回调函数(CALLBACK)的接口来编写程序,使它调用,这个就 称为回调。在调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃。  

    这样的解释似乎还是比较难懂,这里举个简 单的例子:

        程序员A写了一段程序(程序a),其中预留有回调函数接口,并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法,于是,他通过a中的接口回调自己b中的方法。目的达到。   

        在C/C++中,要用回调函数,被掉函数需要告诉调用者自己的指针地址,但在JAVA中没有指针,怎么办?我们可以通过接口(interface)来实现定义回调函数。

        假设我是程序员A,以下是我的程序a:

    [java] view plaincopy
    1. public class Caller {      
    2.         public MyCallInterface mc;    
    3.         public void setCallfuc(MyCallInterface mc){  
    4.               this.mc= mc;      
    5.         }  
    6.           public void call(){  
    7.              this.mc.method();  
    8.         }  
    9.     }      


     我还需要定义一个接口,以便程序员B根据我的定义编写程序实现接口。

    [java] view plaincopy
    1. public interface MyCallInterface {  
    2.            public void method();  
    3.     }       


     

    于是,程序员B只需要实现这个接口就能达到回调的目的了,以下是程序b:

    [java] view plaincopy
    1. public class B implements MyCallInterface {  
    2.          public void method() {  
    3.                 System.out.println("谁来调用我啊。好寂寞!!");      
    4.          }  
    5.          public static void main(String args[]) {  
    6.                Caller call = new Caller();  
    7.                call.setCallfuc(new B());         
    8.                call.call();      
    9.          }  
    10.    }  


     

    ===============================================================================================

    ===============================================================================================

     

    资料二:

    所谓回调,就是客户程序C调用服务程序S中的某个方法a,然后S又在某个时候反过来调用C中的某个方法b,对于C来说,这个b便叫做回调函数。

    一般说来,C不会自己调用b,C提供b的目的就是让S来调用它,而且是C不得不提供。由于S并不知道C提供的b叫甚名谁,所以S会约定b的接口规范(函数原型),然后由C提前通过S的一个函数r告诉S自己将要使用b函数,这个过程称为回调函数的注册,r称为注册函数。

    下面举个通俗的例子:

    某天,我打电话向你请教问题,当然是个难题,:),你一时想不出解决方法,我又不能拿着电话在那里傻等,于是我们约定:等你想出办法后打手机通知我,这样,我就挂掉电话办其它事情去了。过了XX分钟,我的手机响了,你兴高采烈的说问题已经搞定,应该如此这般处理。故事到此结束。

    这个例子说明了“异步+回调”的编程模式。其中,你后来打手机告诉我结果便是一个“回调”过程;我的手机号码必须在以前告诉你,这便是注册回调函数;我的手机号码应该有效并且手机能够接收到你的呼叫,这是回调函数必须符合接口规范。

    如果你还不太清楚看看这段描述合和代码:

    声明一个接口,另外一个类有方法里面有个参数以是这个接口类型的,而后在另外类中实现这个接口(java中多用的是匿名内部类),而且以这个匿名的类生成的对象为参数传到上面提到类中,而后实现回调.......这种用法可以参考java里面常用到的数据库操作所用到的几个接口.....

    [java] view plaincopy
    1. //声明一个接口  
    2. public interface ICallBack {  
    3.     void postExec();  
    4. }  
    5. //另外一个类有方法里面有个参数以是这个接口类型的  
    6. public class FooBar {  
    7.     private ICallBack callBack;  
    8.     public void setCallBack(ICallBack callBack) {  
    9.         this.callBack = callBack;  
    10.     }  
    11.     public void doSth() {  
    12.         callBack.postExec();  
    13.     }  
    14. }  


    回调的实现:

    [java] view plaincopy
    1. public class Test {  
    2.     public static void main(String[] args) {  
    3.         FooBar foo = new FooBar();  
    4.         foo.setCallBack(new ICallBack() {  
    5.             public void postExec() {  
    6.                 System.out.println("method executed.");  
    7.             }  
    8.         });  
    9.         foo.doSth();//调用函数  
    10.     }  
    11. }  


     

    ===============================================================================================

    ===============================================================================================

     

    资料三:一个利用回调函数的经典例子

    下面使用java回调函数来实现一个测试函数运行时间的工具类:

    如果我们要测试一个类的方法的执行时间,通常我们会这样做:

    java 代码

    [java] view plaincopy
    1. public   class  TestObject {     
    2.     /**    
    3.      * 一个用来被测试的方法,进行了一个比较耗时的循环    
    4.      */      
    5.     public   static   void  testMethod(){     
    6.         for ( int  i= 0 ; i< 100000000 ; i++){     
    7.                  
    8.         }     
    9.     }     
    10.     /**    
    11.      * 一个简单的测试方法执行时间的方法    
    12.      */      
    13.     public   void  testTime(){     
    14.         long  begin = System.currentTimeMillis(); //测试起始时间      
    15.         testMethod(); //测试方法      
    16.         long  end = System.currentTimeMillis(); //测试结束时间      
    17.         System.out.println("[use time]:"  + (end - begin)); //打印使用时间      
    18.     }     
    19.          
    20.     public   static   void  main(String[] args) {     
    21.         TestObject test=new  TestObject();     
    22.         test.testTime();     
    23.     }     
    24. }    

     

     

    大家看到了testTime()方法,就只有"//测试方法"是需要改变的,下面我们来做一个函数实现相同功能但更灵活:

    首先定一个回调接口:

    java 代码
     
    public   interface  CallBack {   
        //执行回调操作的方法    
        void  execute();   
    }  

     

    然后再写一个工具类:

    java 代码

    [java] view plaincopy
    1. public   class  Tools {     
    2.          
    3.     /**    
    4.      * 测试函数使用时间,通过定义CallBack接口的execute方法    
    5.      * @param callBack    
    6.      */      
    7.     public   void  testTime(CallBack callBack) {     
    8.         long  begin = System.currentTimeMillis(); //测试起始时间      
    9.         callBack.execute(); ///进行回调操作      
    10.         long  end = System.currentTimeMillis(); //测试结束时间      
    11.         System.out.println("[use time]:"  + (end - begin)); //打印使用时间      
    12.     }     
    13.          
    14.     public   static   void  main(String[] args) {     
    15.         Tools tool = new  Tools();     
    16.         tool.testTime(new  CallBack(){     
    17.             //定义execute方法      
    18.             public   void  execute(){     
    19.                 //这里可以加放一个或多个要测试运行时间的方法      
    20.                 TestObject.testMethod();     
    21.             }     
    22.         });     
    23.     }     
    24.          
    25. }    


    大家看到,testTime()传入定义callback接口的execute()方法就可以实现回调功能

    展开全文
  • 异步是指调用发出后,调用者不会立刻得到结果,...利用回调可以实现Java的异步调用,下面例子来自网上。回调接口:public interface CallBack {/*** 执行回调方法* @param objects 将处理后结果作为参数返回给...

    异步是指调用发出后,调用者不会立刻得到结果,而是在调用发出后,被调用者通知调用者,或通过回调函数处理这个调用。

    回调简单地说就是B中有一个A,这样A在调用B的某个方法时实际上是调用到了自己的方法。

    利用回调可以实现Java的异步调用,下面的例子来自网上。

    回调接口:

    public interface CallBack {

    /**

    * 执行回调方法

    * @param objects 将处理后的结果作为参数返回给回调方法

    */

    public void execute(Object... objects );

    }

    消息的发送者:

    /**

    * 这个类相当于你自己

    */

    public class Local implements CallBack,Runnable{

    private Remote remote;

    /**

    * 发送出去的消息

    */

    private String message;

    public Local(Remote remote, String message) {

    super();

    this.remote = remote;

    this.message = message;

    }

    /**

    * 发送消息

    */

    public void sendMessage()

    {

    /**当前线程的名称**/

    System.out.println(Thread.currentThread().getName());

    /**创建一个新的线程发送消息**/

    Thread thread = new Thread(this);

    thread.start();

    /**当前线程继续执行**/

    System.out.println("Message has been sent by Local~!");

    }

    /**

    * 发送消息后的回调函数

    */

    public void execute(Object... objects ) {

    /**打印返回的消息**/

    System.out.println(objects[0]);

    /**打印发送消息的线程名称**/

    System.out.println(Thread.currentThread().getName());

    /**中断发送消息的线程**/

    Thread.interrupted();

    }

    public static void main(String[] args)

    {

    Local local = new Local(new Remote(),"Hello");

    local.sendMessage();

    }

    public void run() {

    remote.executeMessage(message, this); //这相当于给同学打电话,打完电话之后,这个线程就可以去做其他事情了,只不过等到你的同学打回电话给你的时候你要做出响应

    }

    }

    消息的接收者:

    /**

    * 这个类相当于你的同学

    */

    public class Remote {

    /**

    * 处理消息

    * @param msg 接收的消息

    * @param callBack 回调函数处理类

    */

    public void executeMessage(String msg,CallBack callBack)

    {

    /**模拟远程类正在处理其他事情,可能需要花费许多时间**/

    for(int i=0;i<1000000000;i++)

    {

    }

    /**处理完其他事情,现在来处理消息**/

    System.out.println(msg);

    System.out.println("I hava executed the message by Local");

    /**执行回调**/

    callBack.execute(new String[]{"Nice to meet you~!"}); //这相当于同学执行完之后打电话给你

    }

    }

    这样就可以基于回调实现异步调用,当消息接受者处理任务完成后去调用消息发送者的方法。

    异步调用的类似实现,当图片加载的比较慢时,可以先加载一张模糊的图片,当图片加载完成后再去进行局部的刷新。

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • java 回调函数同步、异步调用

    千次阅读 2016-11-25 15:09:42
    回调函数的应用在于确保串行运算时,同时支持并行的处理。该模式在底层开发模式中应用非常广泛。 package com; /** * java回调应用 * @author zh.h * */ public class TestCallBack { public void ...
    

    回调函数的应用在于确保串行运算时,同时支持并行的处理。该模式在底层开发模式中应用非常广泛。

    package com;
    
    /**
     * java回调应用
     * @author zh.h
     *
     */
    public class TestCallBack {
    
    	public void getIntelRomet(CallBack callBack,String name) throws Exception{
    		Thread.sleep(3000);
    		callBack.solve(name);
    	}
    	
    	public static void main(String[] args) {
    		TestCallBack testCallBack=new TestCallBack();
    		Other other = new Other(testCallBack);
    		try {
    			other.otherPlay("main");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    
    interface CallBack{
    	public void solve(String result);  
    }
    
    class Other implements CallBack{
    	
    	public Other(){
    		
    	}
    	
    	public Other(TestCallBack testCallBack){
    		this.testCallBack=testCallBack;
    	}
    
    	private TestCallBack testCallBack;
    	
    	public void otherPlay(final String name) throws Exception{
    		/**
    		 * 同步回调
    		 */
    		testCallBack.getIntelRomet(Other.this, name);
    		/**
    		 * 异步回调
    		 */
    		new Thread(new Runnable() {
    			@Override
    			public void run() {
    				try {
    					System.out.println("异步回调");
    					testCallBack.getIntelRomet(Other.this, name);
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		}).start();
    		
    		//此处可以定义新的方法进行内部横向扩展。
    		doSomeThing();
    	}
    	
    	public void doSomeThing(){
    		System.out.println("Other 横向内部扩展");
    	}
    	
    	@Override
    	public void solve(String name) {
    		System.out.println("Other 对于接口CallBack 方法的实现==>name:"+name);
    		
    	}
    	
    }
    

    展开全文
  • 异步是指调用发出后,调用者不会立刻得到结果,而是在调用发出后,被调用者通知... 利用回调可以实现Java的异步调用,下面例子来自网上。  回调接口:  public interface CallBack { /** * 执行回...
  • 作为JS核心,回调函数异步执行是紧密相关,也是必须跨过去一道个门槛。那么究竟什么是回调函数(Callback),其实回调函数并不复杂,明白两个重点即可:1. 函数可以作为一个参数在传递到另一个函数中。2. JS是...
  • 同步调用是一种阻塞式单向调用,也是普通程序中最常见的调用方式,假设A函数中部分功能需要由B函数实现,在A函数的某个地方调用了B函数,那么就需要等待B函数执行完毕后,才能继续执行A函数。 这种调用方式仅适用于B...
  • 异步调用,可以实现并行,业务线程可以及时释放,剩下工作交个异步线程完成;提高了执行效率 2、代码示例 1、测试主类 package com.callback2; public class AsyncCallBack { public static void main...
  • Java 异步回调

    千次阅读 2016-11-19 11:47:36
    回调callback一种编程技术,通过将函数A传递给另外一个函数B,由函数B来调用函数A,这样过程被称为回调。通常来说,函数B是已经存在,而函数A可以自定义,这样就能够实现业务多样化。 回调在JavaScript是...
  • 调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃。举例:程序员A写了一段程序(类Caller),其中预留有回调函数接口(MyInterface),并封装好了该程序。程序员B要让...
  • java回调函数.pdf

    2020-08-07 00:18:37
    精品文档 java回调函数利用接口 在 WINDOWS中程序员想让系统 DLL 调用自己编写一个方法 于是利用 DLL 当中回调 函数 CALLBACK的接口来编写程序使它调用这个就称为回调在调用接口时需要严 格按照定义参数...
  • 调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃。这样的解释似乎还是比较难懂,这里举个简 单的例子:程序员A写了一段程序(程序a),其中预留有回调函数接口,...
  • 提供了JSONP请求方法:$.getJSON('http://192.168.0.99/servlet3/getjsonpnew?callback=?')指定需要回调参数名callback,但其值使用一问号替代,作为占位符,jQuery会自动贴心生成一个随机的调用函数名,...
  • 回调函数,主要是为了异步处理 通过callback接口方式实现 执行顺序: 1. test调用testtime 2. testtime函数执行接口 3. 回到test类执行callback接口execute ...使用场景:调用某个函数的时候,一时间不能立刻...
  • java回调函数

    2012-04-11 17:51:12
    调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃。这样的解释似乎还是比较难懂,这里举个简单的例子,程序员A写了一段程序(程序a),其中预留有回调函数接口,并...
  • java使用回调函数

    2020-08-28 14:24:57
    回调函数callback Function),顾名思义就是用来回调的函数。在两个类A、B中,A在调用B接口同时B也在调用A 回调函数也常用于线程中的异步获取消息。 举个简单例子,公司中老板分发任务给员工A,让A完成任务一...
  • 调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃。这样的解释似乎还是比较难懂,这里举个简 单的例子:程序员A写了一段程序(程序a),其中预留有回调函数接口,...
  • Java回调函数详解

    2015-03-29 23:01:00
    为了了解什么是回调函数,在网上查阅了如下资料,整理如下: ...在调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃。 这样的解释似乎还是比较难懂...
  • 在WINDOWS中,程序员想让系统DLL调用自己编写的一个方法,于是利用DLL当中回调函数(CALLBACK)的...在调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃。这样的
  • 调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃。这样的解释似乎还是比较难懂,这里举个简单的例子,程序员A写了一段程序(程序a),其中预留有回调函数接口,并...
  • 为了了解什么是回调函数,在网上查阅了如下资料,整理如下: 资料一: ...在调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃。    这样的解释

空空如也

空空如也

1 2 3
收藏数 51
精华内容 20
关键字:

java异步函数的callback调用

java 订阅