精华内容
下载资源
问答
  • android回调机制
    千次阅读
    2018-02-24 11:34:46

    回调机制基本原理:

    在A类中定义了一个方法,这个方法中用到了一个接口和该接口中的抽象方法,但是抽象方法没有具体的实现,需要B类去实现,B类实现该方法后,它本身不会去调用该方法,而是传递给A类,供A类去调用,这种机制就称为回调。

    相关代码:

    首先需要一个Interface:

    public interface MyInterface {
        void sayYourName();
        void sayMyName();
    }

    然后需要一个类:

    public class MyClass {
        MyClass(){
            Log.i("jinyangyang", "MyClass-constructor");         //标注构造函数
        }
        /* 用接口类型的对象作为输入参数 */
        public void sayYourName(MyInterface myInterface){
            Log.i("jinyangyang", "MyClass-sayYourName_start");    //标注方法开始
            myInterface.sayYourName();                      //遇到不知道具体实现的时候就用接口的抽象方法
            myInterface.sayMyName();
            Log.i("jinyangyang", "MyClass-sayYourName_finish");   //方法结束
        }
    }

    最后一个Activity:


    public class CallbackFunActivity extends AppCompatActivity {
        /*
        所谓的回调函数就是:在A类中定义了一个方法,这个方法中用到了一个接口和该接口中的抽象方法,
        但是抽象方法没有具体的实现,需要B类去实现,B类实现该方法后,它本身不会去调用该方法,
        而是传递给A类,供A类去调用,这种机制就称为回调。
    
        注意:该程序中MyClass相当于A类,CallbackFunActivity相当于B
         */
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_callback_fun);
            MyClass myClass = new MyClass();
            myClass.sayYourName(new MyInterface() {
                @Override
                public void sayYourName() {
                    Log.i("jinyangyang", "sayYourName callBack-interface-implementor");    //具体操作实现
                }
                @Override
                public void sayMyName() {
                    Log.i("jinyangyang", "sayMyName callBack-interface-implementor");     //具体操作实现
                }
            });
        }
    }

    解释:

    A类相当于MyClass类,B类相当于CallbackFunActivity类,MyClass类中调用了接口的抽象方法,但是没有具体的实现,那么需要CallbackFunActivity类来实现,但是CallbackFunActivity类实现之后并不能调用,而是传递给MyClass类来调用。



    更多相关内容
  • 本篇文章主要介绍了Android之接口回调机制,在开发中经常会用到,具有一定的学习价值,有需要的可以来了解一下。
  • 一个Callback的小示例
  • 主要介绍了Android回调函数机制,有需要的朋友可以参考一下
  • Android回调机制浅析

    千次阅读 2016-05-24 17:51:14
    编程工作的层次可以分为系统编程和应用编程: ...可以有三种机制来完成,同步机制,异步机制和回调机制。 本文主要讨论的是回调机制。   回调概述      一般的正向代码流程的都是是应用调用API中的

     

    编程工作的层次可以分为系统编程和应用编程:

    系统编程(system programming):写库方法,API

    应用编程(application programming):调用API实现功能

    系统和应用怎么统一起来实现一个功能呢?可以有三种机制来完成,同步机制,异步机制和回调机制。

    本文主要讨论的是回调机制。

     

    回调概述

     

     

      一般的正向代码流程的都是是应用调用API中的方法实现功能。但有些情况对于应用开发者来说是透明的,比如说你想取快递,快递什么时候到你又不知道,解决的办法有两种,轮询(不停地下楼去看)和委托(叫保安电话通知你),回调机制正是委托的思想。

     

      回调函数就是自己写的,但是不是自己来调,而是给别人来调的函数。也就是说,工作委托给了库函数(或者中间函数),但是事件到达之后,库函数怎么执行(快递来了打电话给你还是跑楼下叫你)需要应用开发者注册给库函数,这个就是回调函数,也叫钩子函数.

     

    如图,回调的过程分三个部分,三方联动:起始函数+中间函数+回调函数

     

     

     


     

     

      如图,回调的过程就成了上层调用下层,下层在执行回调函数的过程,可以看到,回调函数和应用层一般处在同一抽象层。

    在回调机制中,中间函数通过传参或者实现得到回调函数像。可以这么理解,在传入一个回调函数之前,中间函数是不完整的,程序可以在运行时,通过注册不同的回调函数,来决定、改变中间函数的行为。这就是回调函数带来的执行时机和执行逻辑的灵活性。

     

      回调实际上有两种:阻塞式回调和延迟式回调。两者的区别在于:阻塞式回调里,回调函数的调用一定发生在起始函数返回之前;而延迟式回调里,回调函数的调用有可能是在起始函数返回之后,一般牵扯到多线程。

     

      回调的思想是叫别人替你做事,委托的方法,那么事件到来别人需要一个你的引用,但是把自己整个暴露给别人是不安全的,典型的做法是定义接口实现。

     

      回调方法最大的优势在于,异步回调,这样是其最被广为使用的原因,告知被委托人之后,就可以做自己的事情了。

     

    精彩举例:

    通过网上两个精彩的例子来加深对回调函数的例子

     

    网例1:

    你去食堂打饭,你喜欢吃小炒,所以你去了一个小炒窗口。
    你跟老板说了要回锅肉盖饭,老板说:你是11号,喊到你的号你就来拿菜。
    然后你在旁边跟同学吹牛、或者看手机、或者干点你想干的任何事情。
    然后你听到老板喊11号并且把菜放到窗口,你走到窗口,拿到你的菜。

    这里面有几个函数:
    老板的部分:
    1、老板提供一个点餐的函数 boss.Order(string 菜名,double 钱)
    2、老板有个做饭的函数,此函数耗时较长boss.Cook()
    3、 老板提供一个事件,当boss.cook()执行完时,该事件被触发,boss.OnCookFinish;

    你的部分:
    1、你需要有一个函数去订餐,也就是你的函数中需要执行类似于boss.Order("回锅肉盖浇饭",20),比如是me.Hungry(),需要一个boss对象
    2、你需要有一个函数作为回调函数去关注boss.OnCookFinish事件,这样当老板做好饭,你就可以知道是不是你的好了。
    由于老板的事件发生的时候中会喊编号并且吧菜放到窗口,所以你的回调函数需要能够接受1个编号和1个菜作为参数。
    比如me.AcceptFood(int currNumber,object food)

    所以整个程序的流程其实是这样的。

     

    me.Hungry(){
    boss.Order("回锅肉盖浇饭",20);
    boss.OnCookFinish+=me.AcceptFood;//此处表面,AcceptFood这个回调函数关心OnCookFinish事件,并且变成这个事件的回调函数
    //此时这个函数执行完,不再等待
    }

    boss.Order("回锅肉盖浇饭",20){
    boss.Cook();//此处一般会开新线程执行cook动作
    }

    boss.Cook(){
    //cooking~~~~~~~~~~
    OnCookFinish(11号,回锅肉盖浇饭);
    }

     

     

    网例2:

    有个这样的问题:老板(Boss)让工人(Worker)干完活告诉他干的情况如何

    过程如下:

     

    /**
     * 回调事件接口
     */
    public interface Event {
            /**
              * 返回发生事件信息  
              */
                //钩子函数
                    public String happendEvent();
    }
     
    /**
     * 事件
     */
    public class EventA implements Event {
            /**
              * 返回发生事件信息 
              */
                    public String happendEvent() {
                    return "发生了事件 EventA";
                }
    }
     
    /**
     * 事件
     */
    public class EventB implements Event{
            /**
              * 返回发生事件信息 
              */
                    public String getHappendEvent() {
                    return "发生了事件 EventB";
                }
    }
     
    /**
     * 工人类,做重复的工作,做完了之后看发生了哪些事,报告给老板
     */
    public class Worker {
            private Event event;    //事件 
                    private String name;    //工人姓名 
                    private Boss boss;      //工人所属的老板 

                //构造,初始化
                    public Worker(String nameBoss boss) {
                    this.name = name;
                    this.boss = boss;
                }

            /**
              * 干活 
              */
                    public void doWork() {
                    System.out.println(name " is doing working...");
                    //工人干着枯燥乏味的重复工作
                    for (int i = 0i < 2000000i++) {
                           ……
                        }
                    System.out.println(name " was finished work.");
                    //结束了工作之后向老板说明发生的情况,进行回调
                    boss.happendEvent(this, event);
                }

            public Event getEvent() {
                    return event;
                }

            public void setEvent(Event event) {
                    this.event = event;
                }

            public String getName() {
                    return name;
                }

            public void setName(String name) {
                    this.name = name;
                }
    }
     
    /**
     * 老板 委托给工人
     */
    public class Boss {
            private String name;

            public Boss(String name) {
                    this.name = name;
                }

            /**
              * 老板接收工人的事件,注册回调接口(继承或者作为接口传进来),我想在你们工作完成之后知道哪一组发生了什么事
              * @param worker 工人 
              * @param event  事件 
              */
                    public void getWorkerEvent(Worker workerEvent event) {
                    System.out.println("老板接收到事件信息: "+worker.getName() + ": " + event.happendEvent());
                }
    }

     

     

     

    总结:例子中我们可以更深入的理解

    1.上层委托给底层,同时实现了回调机制,注册了回调方法(定义接口,并实现接口)

    2.注册函数,就是setCallback(),把继承实现了接口的类对象传过去

    3.上层给底层发指令开始工作

    4.底层开始工作,工作完成后把结果告诉上层(一般是一个异步耗时的工作)

    5.上层之前已经定义了回调机制,根据底层传回的参数即可迅速反应(回调方法的执行)

     

     

     

    实际代码举例

     

     

     

    实际代码例1:(直接实现接口的方式)

    网络操作返回后调用onFinish执行一定的操作

    1.定义接口和钩子函数

    /**
     * HTTP 请求回调接口
     */
    public interface HttpCallBack {
        void onFinished(int rCode,String result);
    }

     

    2.实现该接口,

    public class TargetRes implements HttpCallBack{ 

    @Override
    public void onFinished(int resCodeString result) {
           Log.d(TAG"onFinished->rCode:" + rCode);
    }

     

    3.底层耗时或异步方法执行完成后调用回调函数

    if(callBack != null){
        callBack.onFinished(tatgetCode,result);
    }

     

    实际代码例2:(接口作为参数传递实现的例子)

    1.定义接口

    public interface ResultCallback {
        public void onFileChanged(int code);
    }

     

    2.使用中new一个接口并进行实现

    ResultCallback mResultCallback = new ResultCallback (){

           @Override
           public void onFileChanged(int code) {
               LogUtil.e(mContextTAG"ResultCallback ---onFileChanged code------"+code);
               mResultCallback .onFileChanged (code);
               if(100 == code){
                   ...
               }
           }

    3.在某个方法中,将接口作为参数传入,实现回调接口的绑定

     

    public void sendFileData(){

    mResultCallback .startSendFile(filePathversionParameterupdateModemResultCallback );

     

    4.在某些类中根据逻辑调用已经注册的回调接口

    a.onFileChanged(process);

     

     

     

     

    实际代码例3:(Android中点击事件的回调机制举例)

     

    //接口
    public interface OnClickListener{

    //回调方法
        void onClick(View v);
    }

     

    //

    public class MainActivity extends Activity implements OnClickListener{
        private Button button;
        @Override
        public void onCreate(Bundle savedInstanceState){
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            button=(Button)findViewById(R.id.button1);

            //注册回调接口,上层给底层分配任务,事件到来时的操作早已经规定好了
            button.setOnClickListener(this);
        }
        //这个是回调函数
        @Override
        public void onClick(View v){
            Toast.makeText(getApplication()"OnClick"Toast.LENGTH_LONG).show();
        }
    }

     

     

     

     

    public class View implements Drawable.CallbackKeyEvent.CallbackAccessibilityEventSource {
        protected OnClickListener mOnClickListener;

        //获取回调实例
        public void setOnClickListener(OnClickListener l) {
            if (!isClickable()) {
                setClickable(true);
            }
            mOnClickListener = l;
        }

      //这里调用回调方法

    public boolean performClick() {
            sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);

            if (mOnClickListener != null) {
                playSoundEffect(SoundEffectConstants.CLICK);

    mOnClickListener.onClick(this);
                return true;
            }

            return false;
        }  

     

     

    展开全文
  • 先介绍下回调机制原理。 回调函数 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用为调用它所指向的函数时,我们就说这是回调函数。回调函数不是由该...
  • 最最简单的android回调的实现,3分钟了解onclicklistener的实现peng'you原理,送给没了解过回调机制的朋友。
  • Android-回调机制

    2020-12-15 16:36:58
    Android-回调机制Android的学习过程中经常会听到或者见到“回调”这个词,那么什么是回调呢?所谓的回调函数就是:在A类中定义了一个方法,这个方法中用到了一个接口和该接口中的抽象方法,但是抽象方法没有具体...

    Android-回调机制

    在Android的学习过程中经常会听到或者见到“回调”这个词,那么什么是回调呢?所谓的回调函数就是:在A类中定义了一个方法,这个方法中用到了一个接口和该接口中的抽象方法,但是抽象方法没有具体的实现,需要B类去实现,B类实现该方法后,它本身不会去调用该方法,而是传递给A类,供A类去调用,这种机制就称为回调。
    在这里插入图片描述
    C不会自己调用b,C提供b的目的就是让S来调用它,而且C不得不提供。S并不知道C提供的b是什么,因此S会约定b的接口规范(函数原型),然后由C提前通过S的一个函数r告诉S自己将要使用b函数(即注册)。r为注册函数。

    回调函数的使用情景:客户程序C调用服务程序S中的某个函数A,然后S又在某个时候反过来调用C中的某个函数B,对于C来说,这个B便叫做回调函数。例如Win32下的窗口过程函数就是一个典型的回调函数。一般说来,C不会自己调用B,C提供B的目的就是让S来调用它,而且是C不得不提供。由于S并不知道C提供的B姓甚名谁,所以S会约定B的接口规范(函数原型),然后由C提前通过S的一个函数R告诉S自己将要使用B函数,这个过程称为回调函数的注册,R称为注册函数。Web Service以及Java的RMI都用到回调机制,可以访问远程服务器程序。
    ( 参考:Android回调机制

    android中好多地方都用到了回调机制,典型的就是各种控件的监听设置:

    //定义接口
    public interface OnClickListenr{
        public void onClick(Button b);
    }
    //定义Button
    public class Button{
        OnClickListener mListener;
        public void click(){
            mListener.onClick(this);
        }
        public void setOnClickListener(OnClickListener listener){
            mListener = listener;
        }
    }
    //将接口对象OnClickListener赋给Button的接口成员
    public class Activity{
        public Activity(){}
        public static void main(String[] args){
            Button mButton = new Button();
            mButton.setOnClickListener(new OnClickListener(){
                @Override
                public void onClick(Button b){
                    System.out.println("clicked");
                }
            });
            mButton.click();  //模拟点击事件
        }
    
    }  
    

    通过这种机制就能很好的解决上述问题,实际实现时,由于回调方法只能监听一个类,而实际情况是每次扫描时就会new一个ScanTask()出来,当时我想的是定义一个静态类型的ScanTask,就可以对其“监听”了

    android回调中最常见的是Button的点击事件的回调,这里以此为参照:

    1、在A类中定义一个接口:需要我们在类中定义出一个接口,并且给这个接口定义出一个抽象方法,就像下面这样:

    public interface CallBack{
            public abstract void work()
        }
    

    以下是View.java类中定义的响应点击事件的接口:

    /**
         * Interface definition for a callback to be invoked when a view is clicked.
         */
        public interface OnClickListener {
            /**
             * Called when a view has been clicked.
             *
             * @param v The view that was clicked.
             */
            void onClick(View v);
        }
    

    2、在A类中定义出该接口的一个成员变量:

    public CallBack mCallBack
    

    以下是View.java类中获取点击事件接口成员变量的源码:

     /**
             * Listener used to dispatch click events.
             * This field should be made private, so it is hidden from the SDK.
             * {@hide}
             */
            public OnClickListener mOnClickListener;
    
    展开全文
  • android回调机制例子让你马上明白

    千次阅读 2015-10-28 20:34:56
    android开发的时候,我总想在MainActivity类以外的类里把数据传回主线程里在更新UI,但是一直想不到怎么做,今天看了《android高级开发实例》让我学会了 回调机制 ,解决了一直困扰我的问题。 好了废话到此结束,...

    在android开发的时候,我总想在MainActivity类以外的类里把数据传回主线程里在更新UI,但是一直想不到怎么做,今天看了《android高级开发实例》让我学会了 回调机制 ,解决了一直困扰我的问题。

    好了废话到此结束,上正片!!


    具体思路:

    1.在另类里获取完数据后调用一个抽象方法;

    2.在主线程里创建一个匿名内部类继承另类,并在匿名内部类里重写抽象方法,方法里完成只能在主线程里完成的工作;

    <!-- 另类里获取完数据后,调用抽象方法,实际上是调用了匿名内部类(子类)重写的方法 -->


    GetJsonl类里通过HTTP协议访问网络(具体用到HttpClient接口),把获得的数据回调到主线程里;

    1.这里写了一个   getresponse  的抽象方法

    2.在完全获取数据后调用 getresponse抽象方法


    public abstract class GetJson {
    
    	public void connect() {
    		// TODO Auto-generated method stub
    		new Thread(new Runnable() {
    
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				try {
    					HttpClient httpClient = new DefaultHttpClient();
    					HttpGet httpGet = new HttpGet(
    							"http://www.weather.com.cn/data/cityinfo/101190404.html");
    					HttpResponse httpResponse = httpClient.execute(httpGet);
    					if (httpResponse.getStatusLine().getStatusCode() == 200) {
    						HttpEntity httpEntity = httpResponse.getEntity();
    						String response = EntityUtils.toString(httpEntity,
    								"UTF-8");
    						getresponse(response.toString());
    					}
    				} catch (Exception e) {
    					// TODO: handle exception
    				}
    			}
    		}).start();
    	}
    
    	public abstract void getresponse(String response);
    
    }

    MainActivity类里:

    1.主线程里 创建一个继承GetJson的匿名内部类,并重写getresponse抽象方法

    2.重写的getresponse方法里调用hanler.sendMessage更新UI


    public class Main_Activity extends Activity {
    	Button button;
    	TextView textview;
    
    	Handler handler = new Handler() {
    		public void handleMessage(Message msg) {
    			textview.setText(msg.toString());
    		}
    	};
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.main_activity);
    		button = (Button) findViewById(R.id.button);
    		textview = (TextView) findViewById(R.id.textview);
                                    GetJson getjson = new GetJson() {
    
    					@Override
    					public void getresponse(String response) {
    						// TODO Auto-generated method stub
    						Message msg = new Message();
    						msg.obj = response;
    						handler.sendMessage(msg);
    					}
    				};
                                    button.setOnClickListener(new View.OnClickListener() {
                                        @Override
                                        public void onClick(View arg0) {
                                              // TODO Auto-generated method stub
                                               getjson.connect();
                                                } 
                                     });
               }
    }


    main_activity.xml

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical" >
    
        <Button
            android:id="@+id/button"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="button" />
    
        <TextView
            android:id="@+id/textview"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
    
    </LinearLayout>


    记得声明权限

     <uses-permission android:name="android.permission.INTERNET" />

    最后打印结果:



    展开全文
  • Android开发中我们很多地方都用到了方法的回调回调就是把方法的定义和功能导入实现分开的一种机制,目的是为了解耦他的本质是基于观察者设计模式,即观察者设计模式的的简化版,例如:在下载时候的进度回调,在...
  • Android回调机制

    千次阅读 2013-06-06 09:49:04
    一、回调函数  回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用为调用它所指向的函数时,我们就说这是回调函数。回调函数不是由该函数的实现方直接...
  • Android 回调机制

    千次阅读 2015-03-27 09:50:10
    Android中到处可见接口回调机制,尤其是UI事件处理方面。举一个最常见的例子button点击事件,button有一个点击方法onClick(),我们知道onclick()是一个回调方法,当用户点击button就执行这个方法。 在Java 中,...
  • android 回调机制

    千次阅读 2014-04-09 18:15:26
    为了实现回调机制的事件处理
  • Android回调函数demo

    2015-12-08 22:47:35
    回调函数在安卓中的使用,简单明了,一个demo入门了解回调机制
  • Android回调机制之Activity与DialogFragment数据传递在实际编程过程中,我们经常碰到这样一种情况:在新建的Dialog或者Fragment中修改数据,但是要在Activity或其他位置进行数据更新,那怎么处理呢?此时我们的回调...
  • Android回调机制的理解

    2014-12-01 20:20:06
    所谓回调就是说一个程序里面有一个函数a,我在这个程序里面调用b函数,我希望b函数来调用我的a函数,这个a函数就叫做回调函数。(网上看了好久才明白0-0) C++对回调的实现: 比如说我在程序里面调用qsort(a,a+n,cmp)...
  • Java回调机制

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

    2020-12-22 20:16:42
     近在看androidFragment与Activity进行数据传递的部分,看到了接口回调的内容,来总结一下。  二、回调的含义和用途  1、什么是回调?  一般来说,模块之间都存在一定的调用关系,从调用方式上看,可以分为...
  • Android接口回调机制接口回调是在Android中运用广泛的一种机制,你一定会眼熟它,接下来,我们从两个方面来了解接口回调Android源码自行动手实际运用1.从setOnclickListener()看接口回调大家都会熟悉这样的写法...
  • android中的回调机制

    2015-09-02 14:37:06
    通过java下的代码实例和android下自定义的按钮功能详细的解释了回调机制以及回调的作用与意义
  • Android回调机制简单总结:Handler更新UI

    千次阅读 2015-10-16 10:48:52
    为了满足项目正常运行有些时候会使用到接口的回调机制,因为之前在操作Fragment和Activity之间进行通信时用到过接口的回调机制,当时没有总结的想法,现在又要使用时,发现已经存有模糊的记忆了,为了便于复习,再次...
  • android中基于回调机制的事件处理.pdf
  • android回调机制

    千次阅读 2011-09-13 16:03:08
    C, C++a或JS里经常有回调方法,它们都是通过指针来实现的。 而JAVA中不允许直接操作指针,那它的回调是如何实现的呢? 答案:它是通过接口(implements)来实现的。 JAVA方法回调是功能定义和功能实现分享的一种...
  • 写作原因:Android回调机制是Android开发者绕不开的一个点,对于它的掌握学习十分重要。本文由于作者水平有限可能存在纰漏,对于回调机制的学习掌握仍在途中,以后会推出更多的相关文章。简介接口回调是Android中一...
  • 回调机制及其在Android开发中的应用.pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,833
精华内容 27,933
关键字:

android回调机制