精华内容
下载资源
问答
  • 回调机制java

    万次阅读 2020-08-19 17:16:35
    回调是什么 回调方将本身传递给调用方,这样调用方就可以在调用完毕之后告诉回调方它想要知道的信息。 类A的a()方法调用类B的b()方法 类B的b()方法执行完毕主动调用类A的callback()方法 简单来说就是A类中调用B类...

    微信搜索:“二十同学” 公众号,欢迎关注一条不一样的成长之路

    回调是什么

    回调方将本身传递给调用方,这样调用方就可以在调用完毕之后告诉回调方它想要知道的信息。

    • 类A的a()方法调用类B的b()方法
    • 类B的b()方法执行完毕主动调用类A的callback()方法

    简单来说就是A类中调用B类中的某个方法C, 然后B类中反过来调用A类中的方法D, D这个方法就叫回调方法

    经典的回调方法的步骤:

    1. class A实现接口CallBack callback——背景1
    2. class A中包含一个class B的引用b ——背景2
    3. class B有一个参数为callback的方法f(CallBack callback) ——背景3
    4. A的对象a调用B的方法 f(CallBack callback) ——A类调用B类的某个方法 C
    5. 然后b就可以在f(CallBack callback)方法中调用A的方法 ——B类调用A类的某个方法D

    回调的分类

    同步回调

    代码运行到某一个位置的时候,如果遇到了需要回调的代码,会在这里等待,等待回调结果返回后再继续执行。

    异步回调

    代码执行到需要回调的代码的时候,并不会停下来,而是继续执行,当然可能过一会回调的结果会返回回来。

    举例

    知道什么是回调了,看个例子理解一下这些抽象的概念和加深一下印象

    开始之前,先想象一个场景:幼稚园的小朋友刚刚学习了10以内的加法。

    第1章. 故事的缘起

    幼师在黑板上写一个式子 “1 + 1 = ”,由小明同学来填空。

    由于已经学习了10以内的加法,小明同学可以完全靠自己来计算这个题目,模拟该过程的代码如下:

     

    public class Student{
    
        private String name = null;
    
        public Student(String name)
        {
         
            this.name = name;
        }
    
        public void setName(String name)
        {
            this.name = name;
        }
    
        private int calcADD(int a, int b)
        {
            return a + b;
        }
    
        public void fillBlank(int a, int b)
        {
            int result = calcADD(a, b);
            System.out.println(name + "心算:" + a + " + " + b + " = " + result);
        }
    }

     

    小明同学在填空(fillBalnk)的时候,直接心算(clacADD)了一下,得出结果是2,并将结果写在空格里。测试代码如下:

    public class Test{
    
        public static void main(String[] args){
    
            int a = 1;
            int b = 1;
            Student s = new Student("小明");
            s.fillBlank(a, b);
        }
    }

     

    运行结果如下:

    小明心算:1 + 1 = 2

    该过程完全由Student类的实例对象单独完成,并未涉及回调机制。

    第2章. 幼师的找茬

    课间,幼师突发奇想在黑板上写了“168 + 291 = ”让小明完成,然后回办公室了。

    花擦!为什么所有老师都跟小明过不去啊?明明超纲了好不好!这时候小明同学明显不能再像上面那样靠心算来完成了,正在懵逼的时候,班上的小红同学递过来一个只能计算加法的计算器(奸商啊)!!!!而小明同学恰好知道怎么用计算器,于是通过计算器计算得到结果并完成了填空。

    计算器的代码为:

     

    public class Calculator{
    
        public int add(int a, int b){
    
            return a + b;
        }
    }

     

    修改Student类,添加使用计算器的方法:

     

    public class Student{
    
        private String name = null;
    
        public Student(String name){
            // TODO Auto-generated constructor stub
            this.name = name;
        }
    
        public void setName(String name){
            this.name = name;
        }
    
        @SuppressWarnings("unused")
        private int calcADD(int a, int b){
            return a + b;
        }
    
        private int useCalculator(int a, int b){
            return new Calculator().add(a, b);
        }
    
        public void fillBlank(int a, int b){
            int result = useCalculator(a, b);
            System.out.println(name + "使用计算器:" + a + " + " + b + " = " + result);
        }
    }

     

    测试代码如下:

     

    public class Test{
    
        public static void main(String[] args){
            int a = 168;
            int b = 291;
            Student s = new Student("小明");
            s.fillBlank(a, b);
        }
    }

     

    运行结果如下:

    小明使用计算器:168 + 291 = 459

    该过程中仍未涉及到回调机制,但是部分小明的部分工作已经实现了转移,由计算器来协助实现。

    3. 幼师回来了

    发现小明完成了3位数的加法,老师觉得小明很聪明,是个可塑之才。于是又在黑板上写下了“26549 + 16487 = ”,让小明上课之前完成填空,然后又回办公室了。

    小明看着教室外面撒欢儿的小伙伴,不禁悲从中来。再不出去玩,这个课间就要废了啊!!!! 看着小红再一次递上来的计算器,小明心生一计:让小红代劳。

    小明告诉小红题目是“26549 + 16487 = ”,然后指出填写结果的具体位置,然后就出去快乐的玩耍了。

    这里,不把小红单独实现出来,而是把这个只能算加法的计算器和小红看成一个整体,一个会算结果还会填空的超级计算器。这个超级计算器需要传的参数是两个加数和要填空的位置,而这些内容需要小明提前告知,也就是小明要把自己的一部分方法暴漏给小红,最简单的方法就是把自己的引用和两个加数一块告诉小红。

    因此,超级计算器的add方法应该包含两个操作数和小明自身的引用,代码如下:

     

    public class SuperCalculator{
    
        public void add(int a, int b, Student  xiaoming){
            int result = a + b;
            xiaoming.fillBlank(a, b, result);
        }
    }

     

    小明这边现在已经不需要心算,也不需要使用计算器了,因此只需要有一个方法可以向小红寻求帮助就行了,代码如下:

     

    public class Student{
    
        private String name = null;
    
        public Student(String name){
            // TODO Auto-generated constructor stub
            this.name = name;
        }
    
        public void setName(String name){
            this.name = name;
        }
    
        public void callHelp (int a, int b){
            new SuperCalculator().add(a, b, this);
        }
    
        public void fillBlank(int a, int b, int result){
            System.out.println(name + "求助小红计算:" + a + " + " + b + " = " + result);
        }
    }

     

    测试代码如下:

     

    public class Test{
    
        public static void main(String[] args){
            int a = 26549;
            int b = 16487;
            Student s = new Student("小明");
            s.callHelp(a, b);
        }
    }

     

    运行结果为:

    小明求助小红计算:26549 + 16487 = 43036

    执行流程为:小明通过自身的callHelp方法调用了小红(new SuperCalculator())的add方法,在调用的时候将自身的引用(this)当做参数一并传入,小红在使用计算器得出结果之后,回调了小明的fillBlank方法,将结果填在了黑板上的空格里。

    灯灯灯!到这里,回调功能就正式登场了,小明的fillBlank方法就是我们常说的回调函数。

    通过这种方式,可以很明显的看出,对于完成老师的填空题这个任务上,小明已经不需要等待到加法做完且结果填写在黑板上才能去跟小伙伴们撒欢了,填空这个工作由超级计算器小红来做了。回调的优势已经开始体现了。

    第4章. 门口的婆婆

    幼稚园的门口有一个头发花白的老婆婆,每天风雨无阻在那里摆着地摊卖一些快过期的垃圾食品。由于年纪大了,脑子有些糊涂,经常算不清楚自己挣了多少钱。有一天,她无意间听到了小明跟小伙伴们吹嘘自己如何在小红的帮助下与幼师斗智斗勇。于是,婆婆决定找到小红牌超级计算器来做自己的小帮手,并提供一包卫龙辣条作为报酬。小红经不住诱惑,答应了。

    回看一下上一章的代码,我们发现小红牌超级计算器的add方法需要的参数是两个整型变量和一个Student对象,但是老婆婆她不是学生,是个小商贩啊,这里肯定要做修改。这种情况下,我们很自然的会想到继承和多态。如果让小明这个学生和老婆婆这个小商贩从一个父类进行继承,那么我们只需要给小红牌超级计算器传入一个父类的引用就可以啦。

    不过,实际使用中,考虑到java的单继承,以及不希望把自身太多东西暴漏给别人,这里使用从接口继承的方式配合内部类来做。

    换句话说,小红希望以后继续向班里的小朋友们提供计算服务,同时还能向老婆婆提供算账服务,甚至以后能够拓展其他人的业务,于是她向所有的顾客约定了一个办法,用于统一的处理,也就是自己需要的操作数和做完计算之后应该怎么做。这个统一的方法,小红做成了一个接口,提供给了大家,代码如下:

    public interface doJob{
         public void fillBlank(int a, int b, int result);
    }

    因为灵感来自帮小明填空,因此小红保留了初心,把所有业务都当做填空(fillBlank)来做。

    同时,小红修改了自己的计算器,使其可以同时处理不同的实现了doJob接口的人,代码如下:

     

    public class SuperCalculator{
    
        public void add(int a, int b, doJob  customer){
            int result = a + b;
            customer.fillBlank(a, b, result);
        }
    }

     

    小明和老婆婆拿到这个接口之后,只要实现了这个接口,就相当于按照统一的模式告诉小红得到结果之后的处理办法,按照之前说的使用内部类来做,代码如下:

    小明的:

     

    public class Student{
    
        private String name = null;
    
        public Student(String name){
            // TODO Auto-generated constructor stub
            this.name = name;
        }
    
        public void setName(String name){
            this.name = name;
        }
    
        public class doHomeWork implements doJob{
    
            @Override
            public void fillBlank(int a, int b, int result){
                // TODO Auto-generated method stub
                System.out.println(name + "求助小红计算:" + a + " + " + b + " = " + result);
            }
    
        }
    
        public void callHelp (int a, int b){
            new SuperCalculator().add(a, b, new doHomeWork());
        }
    }

     

    老婆婆的:

     

    public class Seller{
    
        private String name = null;
    
        public Seller(String name){
            // TODO Auto-generated constructor stub
            this.name = name;
        }
    
        public void setName(String name){
            this.name = name;
        }
    
        public class doHomeWork implements doJob{
    
            @Override
            public void fillBlank(int a, int b, int result){
                // TODO Auto-generated method stub
                System.out.println(name + "求助小红算账:" + a + " + " + b + " = " + result + "元");
            }
    
        }
    
        public void callHelp (int a, int b){
            new SuperCalculator().add(a, b, new doHomeWork());
        }
    }

     

    测试程序如下:

     

    public class Test{
    
        public static void main(String[] args){
            int a = 56;
            int b = 31;
            int c = 26497;
            int d = 11256;
            Student s1 = new Student("小明");
            Seller s2 = new Seller("老婆婆");
    
            s1.callHelp(a, b);
            s2.callHelp(c, d);
        }
    }

     

    运行结果如下:

    小明求助小红计算:56 + 31 = 87
    老婆婆求助小红算账:26497 + 11256 = 37753元

    最后

    可以很明显的看到,小红已经把这件事情当做一个事业来做了,看她给接口命的名字doJob就知道了。

     

    展开全文
  • Java回调机制解读

    2020-08-31 07:38:34
    本文主要介绍了Java回调机制的相关知识,具有很好的参考价值,下面跟着小编一起来看下吧
  • C#的回调机制浅析

    2020-09-04 01:29:22
    主要介绍了C#的回调机制,较为通俗的分析了回调机制的本质与使用时的注意事项,对于C#的学习有一定的参考借鉴价值,需要的朋友可以参考下
  • 详解Java的回调机制

    2020-09-01 09:40:49
    最近学习java,接触到了回调机制(CallBack)。初识时感觉比较混乱,而且在网上搜索到的相关的讲解,本文介绍了Java的回调机制,有兴趣的同学可以了解一下。
  • 主要介绍了Java的回调机制,结合实例形式详细分析了java回调机制相关原理、用法及操作注意事项,需要的朋友可以参考下
  • 主要介绍了java 回调机制的实例详解的相关资料,希望通过本文的示例能帮助到大家理解使用回调机制,需要的朋友可以参考下
  • java回调机制实例详解

    2020-08-30 16:20:30
    主要介绍了java回调机制实例详解的相关资料,需要的朋友可以参考下
  • 在Android中到处可见接口回调机制,尤其是UI事件处理方面,本文给大家介绍android接口回调机制,涉及到android接口回调相关知识,对本文感兴趣的朋友可以参考下本
  • Java回调机制

    2015-11-02 20:32:40
    Java、Android 中常用的回调机制
  • Java 回调机制

    千次阅读 2018-07-17 13:33:44
    Java回调机制概述

    回调机制

    概述

    回调是一种常见的程序设计模式,指可以在某个特定事件发生时应该采取的动作。

    实现

    定义2个类Boss类和Employee类,Boss类负责通知Employee类开始工作,Employee类工作完后通过callback回调通知已经完成工作

    在这里插入图片描述

    class Boss {
        public void execute(Employee employee) {
            employee.work();
        }
    }
    
    class Employee {
    
        interface ICallback {
            void notify(String msg);
        }
    
        private ICallback callback;
    
        public void setCallback(ICallback callback) {
            this.callback = callback;
        }
    
        public void work() {
            System.out.println("开始工作");
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            callback.notify("工作完成");
        }
    }
    
    public class Demo {
        public static void main(String[] args) {
    
            Boss boss = new Boss();
            Employee employee = new Employee();
            employee.setCallback(new Employee.ICallback() {
                @Override
                public void notify(String msg) {
                    System.out.println(msg);
                }
            });
            boss.execute(employee);
        }
    }
    

    文档

    展开全文
  • 最近学习java,接触到了回调机制(CallBack)。初识时感觉比较混乱,而且在网上搜索到的相关的讲解,要么一言带过,要么说的比较单纯的像是给CallBack做了一个定义,本文给大家介绍JAVA的回调机制CallBack,感兴趣的...
  • java调用回调机制详解

    2020-08-18 17:09:45
    主要介绍了java调用回调机制详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 函数回调机制、异步函数回调机制图例详解

    万次阅读 多人点赞 2016-07-29 20:10:49
    无论是JS的函数回调还是Java回调机制,它们思想都是类似的,简单来说就是,如下图所示:    在层次一中的方法一(函数)调用层次二中的方法,而这个被调用的方法又会调用层次一中的方法,这个最后被调用的方法二...

    函数回调机制,一种双向调用思想,简单来说就是,如下图所示:  

             

    在层次一中的方法一(函数)调用层次二中的方法,并传入函数二的地址,而这个被调用的方法又会调用层次一中的方法,这个最后被调用的方法二就是回调方法。方法三调用方法二就是回调的过程。一个有意思的例子,大家可以先感受一下:“诸葛亮给赵子龙一个锦囊,吩咐他危急时打开按锦囊指示办, 锦囊里的命令就是回调函数,危急时刻就是回调的时机。”

    在Java中,这个“层次”可以理解为类,是两个类互相调用对方的方法;也可以理解为应用类(高层)调用类库方法(低层),并传入一个自定义的方法以完成某些功能。

    说到“调用”,模块之间总是存在这一定的接口,模块之间通过这些接口调用以通信联系,从调用方式上看,可以分为三类:同步调用、回调和异步调用

    同步调用是一种阻塞式调用,也是我们在写程序中经常使用的;

    回调是一种双向的调用模式;

    异步调用是一种类似消息或事件的机制,解决了同步阻塞的问题,举例来讲:A通知B后,他们各走各的路,互不影响,不用像同步调用那样,A通知B后,非得等到B走完后,A才继续走。回调是异步调用的基础。下面以一个网络上很流行的例子为基础,理解异步回调机制。


    异步回调典型例子:

    提问者A有个问题"1+1=?",于是A打电话给回答者B,B说他现在很忙,忙完了才能给他想答案,A心想我不能这么一直等着把,于是说:“那咱们约定好,B你想出答案了以打电话的形式告诉我”,挂了电话A也去忙他自己的事了,过了一会B想出答案按A约定好的方式打电话告诉了B答案。

    下面以代码形式描述这个过程:

    /** 
     * 这是一个回调接口,里面定义的方法就是回调函数
     */  
    public interface CallBack {
    	/** 
    	 * 这是一个回调函数,用于回答者B知道答案后给提问者A回电话,并告知提问者A答案是什么
    	 * 这个回电话的方式callBack是提问者A确定的,所以这个方法的实现类是A类
    	 * 这个回电话的内容result是回答者B提供的,所以这个变量的值是在B类中确定的
    	 */ 
    	public void callBack(String result);
    }
    
    /** 
     * 提问者A类
     */ 
    public class A implements CallBack{
    
    	/** 
    	 * 提问者A是知道回答者B的联系方式的
    	 * 这里以一个B类引用代表,并在构造方法中传入B实例对象
    	 */ 
    	private B b;
    	public A(B b){
    		this.b = b;
    	}
    	/** 
    	 * 提问者A向回答者B打电话提问题					
    	 * 这里以一个call方法表示,并把问题参数传入
    	 */ 
    	public void call(final String question){  
    		/** 
    		 * 建立提问者A线程,与回答者B线程结合,构成一个异步的环境
    		 */ 
            new Thread(new Runnable() {  
                @Override  
                public void run() {
                    /** 
                     * B接电话,听问题
                     * 这里以调用回答者B的answer方法表示,传入回调方法类参数、问题参数,以表示谁打的电话,问啥了 
                     * 因为A类实现了CallBack接口,所以A类就是回调方法类,回调方法类实现了回调方法
                     */  
                    b.answer(A.this, question);   
                }  
            }).start();            
            /** 
    		 * 提问者提完问,去干别事情
    		 */   
            doOtherThing();  
        }  
    	
    	public void doOtherThing(){
    		System.out.println("我是提问者A,我问完问题就去干别的事情了!");
    	}
    	
    	/** 
    	 * 刚刚说到,这个回电话的方式callBack是提问者A确定的,所以这个方法的实现类是A类
    	 * 所以这里实现回调方法,代表回复的方法是回电话,由回答者B调用	 
    	 */ 
    	@Override
    	public void callBack(String result) {
    		System.out.println("B调用A定义的回调函数:回答者B告诉提问者A,问题的答案是:"+ result);
    	}
    	
    }
    
    /**
     * 回答者B类
     */
    public class B {
    	/**
    	 * 回答者B接电话,听问题 这里以调用回答者B的answer方法表示,传入回调方法类、问题参数,以表示谁打的电话,问啥了 
    	 */
    	public void answer(CallBack callBack, String question) {
    		System.out.println("A调用B的接电话方法:我是回答者B,提问者A问的问题是:" + question);
    		/**
    		 * 模拟回答者B先忙自己的事 
    		 */
    		System.out.println("我是回答者B,我接完电话先去忙我自己的事!");
    		for (int i = 0; i < 100000; i++) {
    
    		}
    		String result = "2";
    		System.out.println("我是回答者B,我知道了答案是:" + result);
    		/**
    		 * 调用回调函数,打电话告知A答案是什么						
    		 */
    		callBack.callBack(result);
    	}
    }
    
    /** 
     * 场景测试类
     */  
    public class test {
    	public static void main(String args[]){
    		 /** 
    		 * 实例化回答者B
    		 */  
    		B b = new B();
    		 /** 
    		 * 实例化提问者A
    		 */  
    		A a = new A(b);
    		 /** 
    		 * A向B提问,开始
    		 */  
    		a.call("1 + 1 = ?");		
    	}
    }

    (例子原版源自:xiaanming的博客(http://blog.csdn.net/xiaanming/article/details/17483273))

    执行结果:


    函数回调机制也应用于钩子方法,这个可以参考博客: 点击打开链接

    展开全文
  • 主要介绍了Java 异步回调机制实例解析的相关资料,需要的朋友可以参考下
  • 主要为大家详细介绍了java模板和回调机制,学习java模板,感兴趣的朋友可以参考一下
  • 深入浅出Java回调机制

    2020-12-22 16:05:32
    前几天看了一下Spring的部分源码,发现回调机制被大量使用,觉得有必要把Java回调机制的理解归纳总结一下,以方便在研究类似于Spring源码这样的代码时能更加得心应手。  注:本文不想扯很多拗口的话来充场面,我的...
  • handler回调机制 demo

    2016-03-15 09:39:10
    里面包括一个demo,还有handler回调机制的详细讲解内容。
  • 本文将利用Asp.Net的回调机制使用Js实现一个简易进度条
  • 下面小编就为大家分享一篇iOS 监听回调机制KVO实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了Java接口回调机制,下面我们来一起学习一下吧
  • java 回调机制分为:异步回调 同步回调 模块之间总是存在这一定的接口,从调用方式上看,可以分为三类:同步调用、回调和异步调用。同步调用是一种阻塞式调用,也是我们在写程序中经常使用的;回调是一种双向的...
    java 回调机制分为:异步回调   同步回调

    模块之间总是存在这一定的接口,从调用方式上看,可以分为三类:同步调用、回调和异步调用。同步调用是一种阻塞式调用,也是我们在写程序中经常使用的;回调是一种双向的调用模式,也就是说,被调用的接口被调用时也会调用对方的接口,这句话可能有点绕,等文章后面举例说明;异步调用是一种类似消息或事件的机制,解决了同步阻塞的问题,举例来讲:A通知B后,他们各走各的路,互不影响,不用像同步调用那样,A通知B后,非得等到B走完后,A才继续走。回调是异步的基本,因此下面着重说回调机制。


    回调是一种双向调用模式--什么意思呢,就是说,被调用方在被调用时也会调用对方,这就叫回调。

    • 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


    你有一个复杂的问题解决不了,打电话给你的同学,你的同学说可以解决这个问题,但是需要一些时间,那么你不可能一直拿着电话在那里等,你会把你的电话号码告诉他,让他解决之后打电话通知你。回调就是体现在你的同学又反过来拨打你的号码。 
     
     
    展开全文
  • 回调机制详解

    万次阅读 多人点赞 2014-11-06 22:23:12
    今天遇到一位码友问我如何在异步加载完毕后获得异步的返回值,当时我思考了下就让他在异步完成后回调一下将值返回...其实回调机制很好理解,也基于这个原因,也算为了这位仁兄,我决定用最直白的语言来给大家讲讲And
  • 本篇文章主要介绍了Android之接口回调机制,在开发中经常会用到,具有一定的学习价值,有需要的可以来了解一下。
  • 今天小编就为大家分享一篇Python实现Event回调机制的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Android的回调机制

    2014-08-21 15:30:12
    详细介绍Android的回调机制,例举了大量的实例,有助于初学者的学习
  • 主要介绍了通过简易例子讲解Java回调机制,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • android中的回调机制

    2015-09-02 14:37:06
    通过java下的代码实例和android下自定义的按钮功能详细的解释了回调机制以及回调的作用与意义
  • 最好的讲述Java回调机制的博客
  • callback机制回调机制

    千次阅读 2016-12-01 16:50:50
    一、系统自动实现的回调机制 callback 机制在Android 中无处不在,特别是以Handler、Callback、Listener这三个词结尾的,都是利用callback机制来实现的。比如: 1)接口onClickListener就是封装在View中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 337,984
精华内容 135,193
关键字:

回调机制