精华内容
下载资源
问答
  • 接口回调

    2016-08-26 23:03:35
    Android 中的接口回调在android中,接口回调是一种很常见的机制,它可以大大降低代码间耦合性,提高程序的复用性。我们经常碰到的点击事件就是利用的接口回调机制。什么是接口回调接口回调其本质与向上转型是一样的...

    Android 中的接口回调

    在android中,接口回调是一种很常见的机制,它可以大大降低代码间耦合性,提高程序的复用性。我们经常碰到的点击事件就是利用的接口回调机制。

    什么是接口回调

    接口回调其本质与向上转型是一样的,不同的是:接口回调是利用接口句柄来得到并调用实现这个接口的子类引用;而向上转型则是用父类的句柄来得到并调用继承此类的子类的引用。接口回调,强调使用接口来实现回调对象方法,它并不关心方法的具体实现,而向上转型则牵涉到多态和运行期绑定。

    为什么要使用接口回调

    接口回调和java设置模式里面的模板方法模式(Template Method)有点类似,当我们不知道调用者具体要干什么的时候,我们只需要暴露出对应的接口或者抽象方法,让他们自己去实现方法就好的,所以说,接口回调能提高代码的复用性,降低耦合性。

    如何实现接口回调

    下面就简单的说说接口回调的思路:

    • 首先创建一个接口,这个接口用于你在某个情景下执行相应的操作

      public interface Test {
          //接口方法
          public void  doSomething();
      }
      
    • 创建一个功能类,然后,在这个类里面声明回调接口的对象,之后在这个类里面创建在某个情景下需要执行的方法,而且在这个方法里面为声明的接口对象赋值。

      public class Function {
          //声明接口对象
          Test onTest;
      
          public void setOnTest(Test onTest) {
              this.onTest = onTest;
          }
          public  void show(){
              if (onTest!=null) {
                  onTest.doSomething();
              }
          }
      }
      

      还有一种方式,就是不声明接口对象,直接将接口对象以参数的形式传进去

      public class Function {
          public void show(Test onTest){
              if (onTest != null) {
                  onTest.doSomething();
              }
          }
      }
      
    • 在其他的类中使用这个功能类就可以了。这里我们在MainActivity里面来进行测试,在布局文件中写了一个Button和TextView,当点击不同控件的时候进行不同操作。
      布局文件:

      <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      xmlns:tools="http://schemas.android.com/tools"android:layout_width="match_parent"
      android:layout_height="match_parent"
      android:orientation="vertical">
      
          <TextView
              android:id="@+id/tv"
              android:layout_width="wrap_content"
              android:layout_height="wrap_content"
              android:clickable="true"
              android:padding="15dp"
              android:background="#00ffff"
              android:text="TextView" />
      
          <Button 
              android:id="@+id/bt"
              android:layout_width="wrap_content"
              android:layout_height="wrap_content"
              android:text="Button"
              />
      

      MainActivity.java

      public class MainActivity extends Activity implements OnClickListener {
      
          @Override
          protected void onCreate(Bundle savedInstanceState) {
              super.onCreate(savedInstanceState);
              setContentView(R.layout.activity_main);
      
              TextView tv = (TextView) findViewById(R.id.tv);
              Button bt = (Button) findViewById(R.id.bt);
              tv.setOnClickListener(this);
              bt.setOnClickListener(this);
      
          }
      
          @Override
          public void onClick(View v) {
              Function function =new Function();
              switch (v.getId()) {
              //以第一种方式指定点击后执行的具体事件
              case R.id.tv:
                  //设置接口对象
                  function.setOnTest(new Test() {
                      //被点击后要执行的具体事件
                      @Override
                      public void doSomething() {
                          Toast.makeText(MainActivity.this, "TextView被点击了", 0).show();
                      }
                  });
                  //调用功能类里面的方法
                  function.show();
                  break;
              case R.id.bt:
                  //以第二种方式指定点击后执行的具体事件
                  function.show(new Test() {
      
                      @Override
                      public void doSomething() {
                          Toast.makeText(MainActivity.this, "Button被点击了", 0).show();
                      }
                  });
                  break;
      
              }
          }
      }
      
    展开全文
  • 什么是接口回调? 1.接口回调是什么[2]? 接口回调是指:可以把使用某一接口的类创建的对象的引用赋给该接口声明的接口变量,那么该接口变量就可以调用被类实现的接口的方法。实际上,当接口变量调用被类实现的...

    什么是接口回调?
    1.接口回调是什么[2]?
    接口回调是指:可以把使用某一接口的类创建的对象的引用赋给该接口声明的接口变量,那么该接口变量就可以调用被类实现的接口的方法。实际上,当接口变量调用被类实现的接口中的方法时,就是通知相应的对象调用接口的方法,这一过程称为对象功能的接口回调。看下面示例。
    interface People{
    void peopleList();
    }
    class Student implements People{
    public void peopleList(){
    System.out.println(“I’m a student.”);
    }
    }
    class Teacher implements People{
    public void peopleList(){
    System.out.println(“I’m a teacher.”);
    }
    }
    public class Example{
    public static void main(String args[]){
    People a; //声明接口变量
    a=new Student(); //实例化,接口变量中存放对象的引用
    a.peopleList(); //接口回调
    a=new Teacher(); //实例化,接口变量中存放对象的引用
    a.peopleList(); //接口回调
    }
    }
    结果:
    I’m a student.
    I’m a teacher.
    再来看看向上转型(upcasting)的概念。

    2.什么是向上转型[1]?

    Shape s=new Circle();
    这里,创建了一个Circle对象,并把得到的引用立即赋值给Shape。通过继承,Circle就是一种Shape。
    假设你调用基类方法(它已在导出类中被覆盖):
    s.draw();
    由于后期绑定(多态),将会正确调用Circle.draw()方法。

    3.向上转型与接口回调的区别
    看似向上转型和接口回调是一回事。看下面两句话,均出自Thinking in Java。
    使用接口的核心原因:为了能够向上转型为多个基类型[1]。即利用接口的多实现,可向上转型为多个接口基类型(具体见《抽象与接口》章节6)。
    从实现了某接口的对象,得到对此接口的引用,与向上转型为这个对象的基类,实质上效果是一样的。(此句摘自Thinking in Java 3rd 接口与内部类一章)
    所以,我认为,这两个概念是从两个方面来解释一个行为。接口回调的概念,强调使用接口来实现回调对象方法使用权的功能(下一章节详细分析)。而向上转型则牵涉到多态和运行期绑定的范畴。

    4.用 Java 接口实现回调函数的等价功能
    熟悉 MS-Windows 和 X Window System 事件驱动编程模型的开发人员,习惯于传递在某种事件发生时调用(即“回调”)的函数指针。Java 的面向对象模型目前并不支持方法指针,Java 的接口支持提供了一种获得回调的等价功能的机制。其技巧就是:定义一个简单接口,并在该接口中声明我们要调用的方法。
    假定我们希望在某个事件发生时得到通知。我们可以定义一个接口:
    InterestingEvent.java
    package org.zj.sample;
    public interface InterestingEvent {
    public void interestingEvent ();
    }
    这使得我们可以控制实现该接口的类的任何对象。因此,我们不必关心任何外部类型信息。
    发出事件信号的类必须等待实现了 InterestingEvent 接口的对象,并在适当时候调用 interestingEvent() 方法。
    EventNotifier.java
    package org.zj.sample;
    public class EventNotifier {
    private InterestingEvent ie;
    private boolean somethingHappened;

    public EventNotifier(InterestingEvent event) {
         ie = event; // 保存事件对象以备后用。
         somethingHappened = false; // 还没有要报告的事件。
    }
    
    public void doWork() {
         if (somethingHappened) { // 检查设置的谓词。
           ie.interestingEvent();// 通过调用接口的这个方法发出事件信号。
         }
    }
    
    public void setHappened(){//设置谓词。
         somethingHappened=true;
    }
    

    }
    在上例中,使用 somethingHappened 谓词来跟踪是否应触发事件。希望接收事件通知的代码必须实现 InterestingEvent 接口,并将自身引用传递给事件通知程序。
    CallMe.java
    package org.zj.sample;
    public class CallMe implements InterestingEvent {
    @SuppressWarnings(“unused”)
    private EventNotifier en;

    public CallMe() {
         // 注意 EventNotifier (InterestingEvent event),应该传递一个接口类型。
         // 而下面将this,即实现了InterestingEvent接口的CallMe实例传递给
    

    //EventNotifier。也就是所谓的接口回调了。
    en = new EventNotifier(this); // 创建事件通知程序,并将自身引用传递给它。
    }

    // 为事件定义实际的处理程序。
    public void interestingEvent() {
              System.out.println("Call me Hello.");
    }
    

    }
    下面写个测试类。
    Test.java
    package org.zj.sample;
    public class Test {
    public static void main(String[] args) {
    EventNotifier en=new EventNotifier(new CallMe());
    en.setHappened();
    en.doWork();
    }
    }

    结果:
    Call me Hello.

    5.参考资料

    Java回调函数的理解
    http://blog.csdn.net/fengyifei11228/article/details/5729445
    所谓回调,就是客户程序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都用到回调机制,可以访问远程服务器程序。

    下面举个通俗的例子:
    某天,我打电话向你请教问题,当然是个难题,^_^,你一时想不出解决方法,我又不能拿着电话在那里傻等,于是我们约定:等你想出办法后打手机通知我,这样,我就挂掉电话办其它事情去了。过了XX分钟,我的手机响了,你兴高采烈的说问题已经搞定,应该如此这般处理。故事到此结束。这个例子说明了“异步+回调”的编程模式。其中,你后来打手机告诉我结果便是一个“回调”过程;我的手机号码必须在以前告诉你,这便是注册回调函数;我的手机号码应该有效并且手机能够接收到你的呼叫,这是回调函数必须符合接口规范。
    
    通过上面个人感觉到回调更多的应用就是结合异步。比如:Ajax中js通过组件和服务器的异步通信。
    

    例:
    程序员A写了一段程序(程序a),其中预留有回调函数接口,并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法,于是,他通过a中的接口回调自己b中的方法。目的达到。在C/C++中,要用回调函数,被掉函数需要告诉调用者自己的指针地址,但在JAVA中没有指针,怎么办?我们可以通过接口(interface)来实现定义回调函数。
    假设我是程序员A,以下是我的程序a:

    public class Caller
    {
    public MyCallInterface mc;

    public void setCallfuc(MyCallInterface mc)  
    {  
       this.mc= mc;  
    }  
    
    public void call(){  
       this.mc.method();  
    }  
    

    }

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

    public interface MyCallInterface
    {
    public void method();

    }

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

    public class B implements MyCallInterface
    {
    public void method()
    {
    System.out.println(“回调”);
    }

    public static void main(String args[])  
    {  
       Caller call = new Caller();  
       call.setCallfuc(new B());  
       call.call();  
    }  
    

    }

    展开全文
  • 最近在做一个教育类的项目,在开发中大量使用了接口回调来完成网络请求传递数据,特意在这里分享一下自己的心得。 首先官方对接口回调的定义是这样的,所谓回调:就是A类中调用B类中的某个方法C,然后B类中反过来...

    最近在做一个教育类的项目,在开发中大量使用了接口回调来完成网络请求传递数据,特意在这里分享一下自己的心得。

    首先官方对接口回调的定义是这样的,所谓回调:就是A类中调用B类中的某个方法C,然后B类中反过来调用A类中的方法D,D这个方法就叫回调方法。这样听起来有点绕,我们可以这么理解接口回调:比如我们想知道隔壁老王啥时候回家?但是我们有自己的事情做不能一直监视着老王,那么我们可以雇员小区的保安来完成这个任务,当老王回家口,保安就给我们打电话告诉我们,老王回来了!这样就完成了一个事件的传递;

    首先我们定义了一个接口:

    public interface DynamicMessageListener {
    /**
     * 获取网络数据,
     * @param bean bean 对象
     */
    void getDynamicData(List<DynamicBean.DataBean> bean, boolean isMore);
    }
     
        定义一个类实现这个接口:
    
    
    public class DynamicFragment extends Fragment implements DynamicMessageListener {
    //初始化监听者
        private DynamicMessageListener listener;
    /**
         * 获取网络数据
         *
         * @param bean bean 对象
         */
    
        @Override
        public void getDynamicData(List<DynamicBean.DataBean> bean, boolean isMore) {
            if (bean != null && bean.size() > 0) {
                if (!isMore) {
                    adapter = new DynamicAdapter(mContext, bean, this, classID);
                    friendLv.setAdapter(adapter);
                    adapter.setListener(this);
                    LLog.e("activity------有数据");
                } else {
                    adapter.setData(bean);
                }
    
            }
    
        }
    }
    
    
        在网络请求层调用上面的方法:
    
    
    public class DynamicModel extends BaseModel {
    
    
        private Context mContext;
        private NetUtils net;
        private DynamicMessageListener listener;
    
        public DynamicModel(Context mContext, DynamicMessageListener listener) {
            this.mContext = mContext;
            net = NetUtils.getInstance();
            this.listener = listener;
        }
    /**
         * 加载网络数据,
         * @param url    网络url
         * @param params 请求网络携带的参数
         */
        public void loadData(String url, RequestParams params) {
            net.sendGetRequest(url, params, new NetUtils.NetUtilsCallBack() {
                @Override
                public void getNetdata(String json) {
                    if (json != null) {
                        Gson gson = new Gson();
                        DynamicBean bean = gson.fromJson(json, DynamicBean.class);
                        List<DynamicBean.DataBean> data = bean.getData();
                        listener.getDynamicData(data, false);
                        if(data ==null||data.size() <=0 ){
                            listener.friendsNoData(false);
                            LLog.e("没有数据-----");
                        }
                    }
                }
                @Override
                public void loadError(int a) {
                    showError(a, mContext);
                }
            });
        }
    }
    to
    
    

    展开全文
  • 浅析 接口回调

    2020-05-19 21:39:42
    什么是接口回调?为什么要这样?上栗子。

    搞过Android的同志们,尤其是初学者,对于接口回调应该不陌生的,至少应该见过下面的代码:

            //给按钮设置点击事件
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    
                }
            });
    

    OnClickListener就是android系统所预留好的接口,我们写的应用程序中传入回调对象,这样就可以达到接口统一,实现不同的效果。

    什么是接口回调?

    接口回调是用接口句柄来得到并调用实现这个接口的子类的引用。也可以理解为把实现接口的类的实例的引用赋值给接口变量后,该接口变量就可以回调类重写的接口方法。

    听起来有点绕口,举个例子:
    在这里插入图片描述Code B想调用Code A中的A(),但是又想A()在执行的过程中调用Code B自身中的CallB(),那么可以定义一个接口IA,IA可以直接调callB(),CodeB实现IA接口,并且重写了里面的callB(),而Code A通过持有接口IA的引用ia,通过ia.callB()调用callB(),只需要Code B在调用Code A中的A()之前,传入实现接口IA的Code B引用。这个过程就是接口回调。

    用代码描述这个过程:
    IA可以直接调用callB()

    public interface IA {
        void callB();
    }
    

    CodeA通过持有IA接口的引用,直接调用callB()

    public class CodeA {
    
        private IA ia;
        public void setIa(IA ia) {
            this.ia = ia;
        }
    
        public void A() {
            System.out.println("i am is A() of CodeA !");
            ia.callB();
            System.out.println("A() is finished !");
        }
    }
    

    CodeB实现IA接口,重写callB()

    public class CodeB implements IA{
    
        //在调用CodeA.A()之前,传入实现IA接口的CodeB引用
        public void doA() {
            CodeA codeA = new CodeA();
            codeA.setIa(this);
            codeA.A();
        }
    
        @Override
        public void callB() {
            System.out.println("i am is callB() of CodeB !");
        }
    }
    

    测试:

    public class Main {
        public static void main(String[] args) {
            new CodeB().doA();
        }
    }
    

    结果输出:

    i am is A() of CodeA !
    i am is callB() of CodeB !
    A() is finished !
    

    接口回调的好处

    引用博客https://blog.csdn.net/bjyfb/article/details/10462555

    为了使我们写的函数接近完美,就把一部分功能外包给别人,让别人个性化定制,至于别人怎么实现不管,我唯一要做的就是定义好相关接口,这一设计允许了底层代码调用高层定义的子程序,增强程序灵活性,和反射有着异曲同工之妙,这才是回调的真正原因!
    上层模块封装时,很难预料下层模块会如何实现,因此,上层模块只需定义好自己需要但不能预料的接口(也就是回调接口),当下层模块调用上层模块时,根据当前需要的实现回调接口,并通过注册或参数方式传入上层模块即可,这样就实现下层调用上层,并且上层还能根据传入的引用来调用下层的具体实现,将程序的灵活性大大的增加了。

    展开全文
  • Java 接口做参数,接口回调

    千次阅读 2020-07-05 15:53:33
    JAVA接口做参数,接口回调 接口做参数:将实现某接口的类的对象的引用用作参数传递给该接口参数。该接口通过回调来实现该接口方法。 接口回调:实现某接口的类的对象的引用,赋值给该接口声明的接口变量。 难以理解...
  • Java接口回调详解

    千次阅读 多人点赞 2018-08-29 16:15:33
    产生接口回调的场景 在现实生活中,产生接口回调的场景很简单,比如我主动叫你帮我做一件事,然后你做完这件事之后会通知我,"通知我"这个动作就是接口回调的动作.接口回调重在理解思就好.再举个例子用于下面...
  • Unity 接口回调

    2019-03-01 13:47:51
    经常看到一些Unity的接口回调,比如Unity中的OnCollisionEnter、OnTriggerEnter等等。现在想自己写一个类似的接口回调。 首先拟定一个场景,假设想要监测一个游戏对象的运动状态。首先定义一个接口,保存三个状态...
  • java 接口回调

    2017-05-25 17:30:48
    java 接口回调
  • 【java|Android接口回调】小小猿理解的接口回调  所谓的回调函数就是:在A类中定义了一个方法,这个方法中用到了一个接口和该接口中的抽象方法,但是抽象方法没有具体的实现,需要B类去实现,B类实现该方法后...
  • JNI 接口回调

    千次阅读 2019-01-24 22:27:06
    JNI 接口回调 这里主要演示从 Java 层传入自定义listener,然后由 c/c++ 层在某一时期某一线程主动调用 listener 的回调函数,完成异步回调的功能。 关于 jni 的其他部分基础知识本文不做详细介绍。 Java 层定义代码...
  • 巧妙理解接口回调

    2020-04-23 19:16:24
    一、为什么会有接口回调?什么是接口回调? 其实这两个问题是一个问题,知道了接口回调的原理自然就知道了为什么会有这么个东西。我们知道java中接口是不可以直接创建实例的,那么问题来了,假如我把一个接口声明为...
  • Java的接口回调与回调函数的解析

    千次阅读 2016-04-01 00:14:05
    原文链接:Java中什么是接口回调?and Java回调函数的理解 什么是接口回调? 1.接口回调是什么[2] 接口回调是指:可以把使用某一接口的类创建的对象的引用赋给该接口声明的接口变量,那么该接口变量就可以...
  • 接口回调原理

    2018-05-16 08:18:07
    在使用接口回调的时候发现了一个经常犯的错误,就是回调函数里面的实现有可能是用多线程或者是异步任务去做的,这就会导致我们期望函数回调完毕去返回一个主函数的结果,实际发现是行不通的,因为如果回调是多线程的...
  • Android 接口回调实例

    千次阅读 2015-05-14 14:42:35
    Android接口回调方法处处涉及到,比如常用的Button点击事件就是一个接口回调,可见掌握熟练使用接口回调方法的重要性。 接口回调的简单解释就是:比如我这个类实现了一个接口里的方法doSomething,然后注册到你这里...
  • Java接口回调

    2016-12-16 10:02:17
    但是java的“多态”给了我们契机,在调用这个方法的时候JVM会自动去找其子类,也就是调用其子类中实现的该方法,这是接口回调的本质。所以说,只需要给该变量指向其子类的地址就可以在调用的时候知道调用子类的方法...
  • Java:案例理解-接口回调

    千次阅读 多人点赞 2020-12-14 17:46:22
    Java:案例理解-接口回调 接口回调的设计在实际应用中很多,其概念单从文字角度比较难以理解 那么下面就一个简单的实际应用案例理解 建议: 跟着动手敲一敲,画调用关系图,然后看注释反复理解 案例要求: 岳老板命令...
  • 详解Android中接口回调、方法回调

    万次阅读 多人点赞 2018-04-26 10:26:13
    转载地址:http://www.jb51.net/article/102520.htmhttps://blog.csdn.net/u010566681/article/details/52371359我理解的接口回调就是,我这个类实现了一个接口里的方法doSomething,然后注册到你这里,然后我就去做...
  • 安卓接口回调

    2015-09-18 11:06:18
    理解能力渣渣,接口回调技术曾经用了两星期去理解才理解,说理解我都不自信,因为我都不知道我写的是不是接口回调,只是因为我看着长得像,就写出来看看,顺便做自我记录,恳请大神们拍砖。 首先感谢loader大神和...
  • java接口回调实例

    千次阅读 2018-05-09 22:41:58
    Java Interface ——接口回调解析及实例通常的认知中java的接口就是用来定义一两个功能函数,其实现类来重写实现这些方法,今天给大家介绍一种很受欢迎且有很大益处的使用方法——接口回调...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,581
精华内容 7,432
关键字:

接口回调