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

    2021-01-20 03:42:48
    接口回调是多态的另一种体现。接口回调是指:可以把使用某一个接口的类创建的对象的引用赋给该接口声明的接口变量中,那么该接口变量可以调用被类实现的接口中的方法。当接口变量调用被类实现的接口中的方法时,是...
  • java接口回调

    2017-03-23 00:18:43
    http://blog.csdn.net/IT_XF/article/details/65058367
  • 比如说讯飞的语音识别,我们调用它的识别方法之后不是马上就可以得到识别的结果,需要经过一段时间(网络传输耗时),但是我们不会让程序傻逼地等待它的返回结果,而是让classA实现它定义的接口IntefaceC,当讯飞的...
  • 具体代码,从项目中直接拿出来的,需要根据博客自己筛选有用部分
  • 通过简单的自定义Dialog来理解接口回调callback机制
  • Activity与Fragment通过接口回调进行通信
  • Android:RecyclerView添加点击事件,接口回调示例讲解的Demo。
  • 接口回调之Fragment之间通信
  • android接口回调详解、简单例子+复杂例子
  • Java接口回调

    千次阅读 2020-01-03 13:48:30
    回调的含义和用途 什么是回调? 一般来说,模块之间都存在一定的调用关系,从调用方式上看,可以分为三类:同步调用、异步调用和回调。同步调用是一种阻塞式调用,即在函数A的函数体里通过书写函数B的函数名来调用...

    回调的含义和用途

    什么是回调?

    一般来说,模块之间都存在一定的调用关系,从调用方式上看,可以分为三类:同步调用异步调用回调。同步调用是一种阻塞式调用,即在函数A的函数体里通过书写函数B的函数名来调用之,使内存中对应函数B的代码得以执行。异步调用是一种类似消息或事件的机制解决了同步阻塞的问题,例如 A通知 B后,他们各走各的路,互不影响,不用像同步调用那样, A通知 B后,非得等到 B走完后, A才继续走 。回调是一种双向的调用模式,也就是说,被调用的接口被调用时也会调用对方的接口,例如A要调用B,B在执行完又要调用A。

    回调的用处

    回调一般用于层间协作,上层将本层函数安装在下层,这个函数就是回调,而下层在一定条件下触发回调。例如作为一个驱动,是一个底层,他在收到一个数据时,除了完成本层的处理工作外,还将进行回调,将这个数据交给上层应用层来做进一步处理,这在分层的数据通信中很普遍。

    Java中接口回调机制

    java接口回调机制想必大家并不陌生,其思想简单,应用广泛,如网络请求、界面的点击监听等,是一个java开发者必须要掌握的基本思想之一。

    我们在做java开发时经常会遇到文件下载、请求服务器数据等基本操作,大家都知道网络请求属于耗时操作,我们如果在直接主线程执行这些逻辑时很可能会造成主线程堵塞,从而导致程序崩溃。我们通常都是开启一个子线程来执行网络请求操作。

        public void doSomeWork() {
            new Thread(new Runnable() {
                @Override
                public void run() {
    
                        // 执行逻辑,发起网络请求,如请求后台数据,下载文件等
    
                }
            }).start();
    }

    上面这段代码想必你已经再熟悉不过了,不过当我们在做一次开发时,经常会多次使用网络请求,比如多次请求服务器的数据,所以我们更愿意将其写成一个小框架: 

    public String doRequest(String url) {
            new Thread(new Runnable() {
                @Override
                public void run() {
    
                        // 执行逻辑,请求后台json数据
    
                }
            }).start();
            //将获取的数据转化为String,并返回
        }

    那么问题来了: 我们在写成框架时,网络请求是在子线程中进行的,很可能数据还没返回来的时候,doRequest方法就已经执行完了(不懂的就需要去看看守护线程哦),那么这时候返回的数据就没有任何意义了,最终的结果是我们得到的String为空的,而不是我们期待的的数据。

    解决此问题的一种方法: 子线程请求到数据后,直接对数据进行处理(缺陷:失去了框架的意义)

    public void doRequestAndDealData(String url) {
            new Thread(new Runnable() {
                @Override
                public void run() {
    
                        // 执行逻辑,请求后台json数据
                        // 直接对获取到的数据进行处理
    
                }
            }).start();
        }

    对比上一段代码,我们这里直接对返回的数据进行了处理,而没有在方法里返回数据,但是这样的处理逻辑就是唯一的了,并不能随着请求的url不同而执行不同的处理逻辑,那么有没有一种方法能将在子线程中获取到的数据"传出去",使其能得到成功的处理呢? 这就是接口回调的巧妙之处了!

    • 先定义一个接口

    public abstract class CallBackListener {
    
        public abstract void onFinish()
    
        public abstract void onError(Exception ex);
    
    }
    • 在类A中通过在子线程发起网络请求,并将接口作为参数,写到类A中!

    public class A {
        public void doRequest(String url,CallBackListener backListener) {
            new Thread(new Runnable() {
                @Override
                public void run() {
    
                    try {
                        // 执行逻辑,发起网络请求,如请求后台数据,下载文件等
                        backListener.onFinish();
    
                    } catch (Exception ex) {
                        backListener.onError(ex);
                    }
                }
            }).start();
        }
    }
    • 在类B中调用类A的对象,发起请求,并且对请求得到的数据进行处理。

    public class B {
        public void deal() {
            A a = new A();
            a.doRequest("http://请求的url",new CallBackListener() {
                @Override
                public void onFinish() {
                    //请求成功的逻辑,如下载完成后的处理,请求到数据后的处理
                }
    
                @Override
                public void onError(Exception ex) {
                    // 异常逻辑
                }
            });
        }
    }

    我们在B中调用A的方法时,重写了接口中的方法,当发起的网络请求完成时,就会调用我们重写后的方法,这就是接口回调,这样根据需要来进行不同的重写,同样保留了框架的意义。

    我们在下载完成后,界面的点击事件监听,后台数据请求完成时...还有很多地方都可以用到接口回调,掌握其思想后,我们也可以写的更加规范一点了,如将A类中的接口作参数就写为单的一个方法,setListener(CallBackListener listener);

    展开全文
  • 微信支付-商户支付模式一url接口回调-java版,代码清晰,可直接运行
  • Lambda 表达式使用Kotlin高阶函数实现接口回调Java中接口使用Kotlin中接口使用 什么是高阶函数? 高阶函数是将函数作为参数或者返回值的函数。 特点 参数可以是函数 返回值可以是函数 所有函数类型都有一个圆括号...

    什么是高阶函数?

    高阶函数是将函数作为参数或者返回值的函数

    • 特点

      • 参数可以是函数
      • 返回值可以是函数
      • 所有函数类型都有一个圆括号括起来的参数类型列表及一个返回类型
    • 举个🌰

      var onClick:()->Util      //onClick变量类型为:无参且无返回类型的函数
      var onClick:(A,B)->C      //onCick变量类型为:参数类型分别为A,B,返回类型为C的函数
      
      (x:Int,y:Int)             //函数类型可以选择性包含函数的参数名,用于表明参数含义 
      
      ((Int,Int)->Util)?        //如果函数类型可为空,要使用圆括号后加?
      

      上述就是一个高阶函数用法,定义某个变量的类型为函数,

      注意:

      • 参数类型可以为空()
      • Unit返回类型不可省略
    • 函数类型实例调用

      函数类型的值可以通过其invoke(...)操作符调用:f.invoke(x)或者直接f(x)

    Lambda 表达式

    • 简述

      • lambda 表达式总是被大括号括着,
      • 其参数(如果有的话)在 —> 之前声明(参数类型可以省略),
      • 函数体(如果存在的话)在 —> 后面。
      • lambda隐式返回最后一个表达式的值(或者使用限定的返回语法显示返回一个值)
    • 语法

      val sum:(Int,Int)->Int={ x:Int,y:Int->x+y}
      

    在 Kotlin 中有一个约定,如果函数的最后一个参数是一个函数,并且你传递一个 lambda 表达式作为相应的参数,你可以在圆括号之外指定它

    比如map函数

    //map函数最后一个参数是一个函数
    fun <T, R> List<T>.map(transform: (T) -> R): List<R> {
          val result = arrayListOf<R>()
          for (item in this)
            result.add(transform(item))
          return result
         }
    
    //使用
    val dataList = list.map{it—>
                it*2
    	}
    

    使用Kotlin高阶函数实现接口回调

    在学习使用Kotlin高阶函数实现接口回调之前,先看看我们在Java中接口回调通常使用方法

    Java中接口使用

    • 普通使用

      定义接口

      public interface ICallback {
          void nextFun(String message);
      
          void errorFun(int code, String message);
      }
      

      业务中使用

      public class LoginLogicImpl {
          //声明login方法,参数为ICallback回调接口类型
          public void login(ICallback callback) {
              //TODO...
              if (true) {
                  callback.nextFun("success");
              } else {
                  callback.errorFun(404, "not found page");
              }
          }
      }
      

      外部调用(通过匿名内实现接口的回调)

      public class LoginLogicPresenter {
          LoginLogicImpl loginLogic = new LoginLogicImpl();
      
          public void login() {
              loginLogic = new LoginLogicImpl();
              /**
               *调用LoginLogicImpl的login方法,通过new ICallback()匿名类方式实现接口回调。
               *必须显示声明所有接口中的回调方法。
               */
              loginLogic.login(new ICallback() {
                  @Override
                  public void nextFun(String message) {
      								Log.d(TAG,"message->" + message)
                  }
      
                  @Override
                  public void errorFun(int code, String message) {
      								Log.e(TAG,"code->" + code + "message->" + message)
                  }
              });
          }
      }
      

      如上我们在使用该接口时候,需要显示的声明接口内所有的回调方法,如果不需要显示声明所有借口回调方法怎么办呢? 那么我们可以通过提供一个该接口的实现类来达到需求,具体实现如下

    • 简单使用

      声明接口的实现类

      public class CallbackImpl implements ICallback {
          @Override
          public void nextFun(String message) {
      
          }
      
          @Override
          public void errorFun(int code, String message) {
      
          }
      }
      

      业务中使用

      public class LoginLogicImpl {
              //声明函数,参数为回调接口的实现类
              public void register(CallbackImpl callbackImpl){
                  //TODO...
                  if(true){
                      callbackImpl.nextFun("success");
                  }else{
                      callbackImpl.errorFun(404,"not found page");
                  }
              }
      }
      

      外部调用

       public class LoginLogicPresenter {
          LoginLogicImpl loginLogic = new LoginLogicImpl();
          public void register() {
                  /**
                   *调用LoginLogicImpl的register方法,通过new CallbackImpl()匿名类
                   *实现回调(可选择性的显示声明接口内回调方法)
                   */
                  loginLogic.register(new CallbackImpl() {
                      @Override
                      public void nextFun(String message) {
                          super.nextFun(message);
                          Log.d(TAG,"success->" + message);
                      }
                      //@Override  可根据需要选择性的显示回调方法
                      //public void errorFun(int code, String message) {
                      //    super.errorFun(code, message);
                      //}
                  });
              }
       }
      

    Kotlin中接口使用

    在kotlin中如果我们按照Java的思想进行接口开发使用,大概会有如下实现

    • Kotlin中接口普通使用

      定义接口

      interface ICallback {
          fun nextFun(message: String)
          fun errorFun(code: Int, message: String)
      }
      

      业务中使用

      object LoginLogicImpl {
          //声明login方法,参数为:ICallback回调接口类型
          fun login( callback: ICallback) {
              //todo...
              if (true) {
                  callback.nextFun("success")
              } else {
                  callback.errorFun(400, "failure...")
              }
          }
      }
      

      外部使用(使用object对象表达式,类似于java中的匿名类

      class LoginLogicPresenter {
          fun login() {
              /**
               *调用LoginLogicImpl的login方法,使用object对象表达式实现接口回调(必须要显示声明接口中
               *全部回调方法)
               */
              LoginLogicImpl.login(object : ICallback {
                  override fun nextFun(message: String) {
                      println("success->$message")
                  }
      
                  override fun errorFun(code: Int, message: String) {
                      println("failure->$code,$message")
                  }
              })
          }
      }
      

      上面就是我们在kotlin中通过java思想实现的接口,使用了object对象表达式(类似Java中匿名类) 实现回调。

      在我们使用Android系统提供的View的setOnClickListener方法时候,我们发现其除了提供object对象表达式方式之外,还提供了setOnClickListener(it->)方法,如下

      button.setOnClickListener(object :View.OnClickListener{
                  override fun onClick(v: View?) {
                     //TODO
                  }
       })
      
      button.setOnClickListener {it->
          //TODO
      }
      

      可见后者并没有使用object对象表达式,而是通过kotlin的高阶函数Lambda表达式实现。那么我们是不是也可以将我们之前的接口更改为此种方式呢?当然可以!!如下:

    • 使用Kotlin高级函数和Lambda优化接口回调

      • 定义接口:声明回调函数

        /**
         *定义回调接口
         */
        interface IResponseCallback<T> {
            
            fun nextFun(data: T?) 
            
            fun errorFun(code: Int, message: String)   
        }
        
      • 定义接口实现类:声明函数类型变量和对外提供的回调方法(与接口回调功能保持一致),并实现接口内回调方法

        • 声明函数类型变量(参数与接口回调函数一致)

          class ResponseCallbackListener<T> : IResponseCallback<T> {
              //通过高阶函数声明函数类型变量(参数与接口互调函数一致)
              lateinit var next: (data: T?) -> Unit 
              lateinit var error: (code: Int, message: String) -> Unit  
          }
          
        • 声明回调方法(要与接口提供回调功能一致)

          class ResponseCallbackListener<T> : IResponseCallback<T> {
              //通过高阶函数声明函数类型变量(参数与接口互调函数一致)
              lateinit var next: (data: T?) -> Unit 
              lateinit var error: (code: Int, message: String) -> Unit 
          
              
              //声明回调方法(与接口回调功能一致),参数为对应的函数类型变量
              fun OnNext(nextListener: (data: T?) -> Unit) {
                  this.next = nextListener
              }
              fun OnError(errorListener: (code: Int, message: String) -> Unit) {
                  this.error = errorListener
              }
          }
          
        • 实现接口内回调方法

          class ResponseCallbackListener<T> : IResponseCallback<T> {
            
              //通过高阶函数声明函数类型变量(参数与接口互调函数一致)
              lateinit var next: (data: T?) -> Unit 
              lateinit var error: (code: Int, message: String) -> Unit 
          
              
            
              //声明回调方法(与接口回调功能一致),参数为对应的函数类型变量
              fun OnNext(nextListener: (data: T?) -> Unit) {
                  this.next = nextListener
              }
              fun OnError(errorListener: (code: Int, message: String) -> Unit) {
                  this.error = errorListener
              }
            
             
              //实现接口内回调方法,调用对应函数变量的invoke(param)方法实现回调
              override fun nextFun(data: T?) {
                  //函数类型的值可以通过其 invoke(……) 操作符调用:f.invoke(x) 或者直接 f(x)。
                  this.next.invoke(data)  
                  //this.next(data)
              }
              override fun errorFun(code: Int, message: String) {
                  this.error.invoke(code, message)
              }
          }
          
    • 使用

      业务中使用

      object LoginLogicImpl {
          //声明register方法,参数为:函数类型
          fun register(callback: CallbackListenerImpl.() -> Unit) {
              var callBack = CallbackListenerImpl()   //实例化回调接口实现类
              callBack.callback()										  //将参数内的回调函数与实例化对象绑定
            
              if (true) {
                  callBack.nextFun("success")            //成功回调
              } else {
                  callBack.errorFun(400, "failure...")   //失败回调
              }
          }
      }
      

      外部调用

      class LoginLogicPresenter {
          fun register() {
              //调用LoginLogicImpl的register方法(可选择性显示声明回调方法)
              LoginLogicImpl.register {
                  OnNext {
                      println("OnNext->$it")
                  }
                  //OnError { code, message ->
                  //    println("OnError->$code,$message")
                  //}
              }
          }
      }
      

      上面使用Kotlin的高阶函数以及Lambda表达式对普通的接口回调进行优化,并没使用object对象表达式实现了接口回调,并且不需要显示声明接口提供的所有回调方法,而是选择性的声明所需的回调方法即可。

    更多Kotlin高阶函数及Lambda表达式学习地址参见《Kotlin中文社区

    展开全文
  • JNI 接口回调

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

    JNI 接口回调

    这里主要演示从 Java 层传入自定义listener,然后由 c/c++ 层在某一时期某一线程主动调用 listener 的回调函数,完成异步回调的功能。
    关于 jni 的其他部分基础知识本文不做详细介绍。

    Java 层定义代码
    • java-native 函数以及接口定义

      package com.jnidemo;
      
      public class Greet {
      
          static {
              System.loadLibrary("jni_demo");
          }
      
          public native void native_say_hello(GreetListener listener);
      
          public interface GreetListener {
              /**
               * 这里为了演示自定义 Callback 的用法,使用了自定义 Java-Callback 类作为回调参数,
               * 可直接使用基本类型或者其他引用类型做回调参数,根据自己的业务需求决定。
               */
              void onGreetReceive(GreetCallback greet);
          }
      }
      
    • java 自定义 Callback 类

      package com.jnidemo;
      
      public class GreetCallback {
      
          private int greetID;
          private String greetMsg;
      
          public GreetCallback(int greetID, String greetMsg) {
              this.greetID = greetID;
              this.greetMsg = greetMsg;
          }
      }
      
    c++ 层实现代码
    • 动态注册 native 实现函数

      const char *NATIVE_GREET_CLASS_NAME = "com/jnidemo/Greet";
      
      static JNINativeMethod gMethods_Greet[] = {
          {"native_say_hello", "(Lcom/jnidemo/Greet$GreetListener;)V", (void *)say_hello_jni}
      };
      
      static int registerNativeMethods(JNIEnv *env)
      {
          jclass clazz = env->FindClass(NATIVE_GREET_CLASS_NAME);
          if (clazz == NULL)
              return JNI_FALSE;
          if (env->RegisterNatives(clazz, gMethods_Greet, sizeof(gMethods_Greet) / sizeof(gMethods_Greet[0])) < 0)
              return JNI_FALSE;
          env->DeleteLocalRef(clazz);
          clazz = NULL;
          return JNI_TRUE;
      }
      
      jint JNI_OnLoad(JavaVM *vm, void *reserved)
      {
          JNIEnv *env = NULL;
          if (vm->GetEnv((void **)&env, JNI_VERSION_1_6) != JNI_OK)
              return -1;
          assert(env != NULL);
          if (!registerNativeMethods(env))
              return -1;
      
          hover_jvm = vm;
          return JNI_VERSION_1_6;
      }
      
    • native 函数实现

      typedef struct
      {
          jobject o_greet_listener;
          jmethodID m_greet_receive;
      
          jclass z_greet_callback;
          jmethodID m_greet_callback_init;
      } jni_callback_t;
      
      // 定义承载 Java-Listener 和 Java-Callback 实例和 methodID 的结构体实例
      static jni_callback_t *jni_callback;
      
      /**
       * jni 动态注册对应的 native 实现函数。
       * 创建 Java-Listener 和 Java-Callback 的实例和 methodID 并赋值给 jni_callback_t.
       */
      static void say_hello_jni(JNIEnv *env, jobject object, jobject greet_listener)
      {
          if(!greet_listener)
              return;
      
          // 获得回调接口 函数onGreetReceive 的 methodID.
          jclass clazz_greet_listener = env->GetObjectClass(greet_listener);
          jmethodID method_greet_receive = env->GetMethodID(clazz_greet_listener, "onGreetReceive", "(Lcom/jnidemo/GreetCallback;)V");
      
          // 获得自定义 Callback类 GreetCallback 构造函数的 methodID.
          jclass clazz_greet_callback = env->FindClass("com/jnidemo/GreetCallback");
          jmethodID method_greet_callback_init = env->GetMethodID(clazz_greet_callback, "<init>", "(ILjava/lang/String;)V");
      
          // 这里创建 jni_callback_t 的实例,创建 Listener 和 Callback 的全局引用并赋值.
          jni_callback = (jni_callback_t *)malloc(sizeof(jni_callback_t));
          memset(jni_callback, 0, sizeof(jni_callback_t));
          jni_callback->o_greet_listener = env->NewGlobalRef(greet_listener);
          jni_callback->m_greet_receive = method_greet_receive;
          jni_callback->z_greet_callback = (jclass)env->NewGlobalRef(clazz_greet_callback);
          jni_callback->m_greet_callback_init = method_greet_callback_init;
      
          // 销毁局部引用
          env->DeleteLocalRef(clazz_greet_listener);
          env->DeleteLocalRef(clazz_greet_callback);
          clazz_greet_listener = NULL;
          clazz_greet_callback = NULL;
      
          // 这里创建子线程模拟异步回调
          pthread_t ntid;
          pthread_create(&ntid, NULL, async_thread_func, NULL);
      }
      
    • native 端子线程模拟回调

      void *async_thread_func(void *args)
      {
          // JNI_OnLoad 时保存 jvm,这里使用 jvm->AttachCurrentThread 获取 JNIEnv,暂不做详细介绍.
          JNIEnv *env = NULL;
          hover_attach_jni_env(&env);
      
          // 使用 java 构造函数生成 GreetCallback 的实例
          int greetID = 1;
          jstring greetMsg = env->NewStringUTF("say hi to java.");
          jobject greet_callback = env->NewObject(jni_callback->z_greet_callback, jni_callback->m_greet_callback_init, greetID, greetMsg);
      
          // 调用 GreetListener 的 onGreetReceive 函数,完成调用流程.
          env->CallVoidMethod(jni_callback->o_greet_listener, jni_callback->m_greet_receive, greet_callback);
      
          // 销毁局部引用
          env->DeleteLocalRef(greetMsg);
          env->DeleteLocalRef(greet_callback);
          greetMsg = NULL;
          greet_callback = NULL;
      
          // 销毁全局引用 --- 如果有多处或多次回调,自行判断销毁时机.
          env->DeleteGlobalRef(jni_callback->o_greet_listener);
          env->DeleteGlobalRef(jni_callback->z_greet_callback);
          jni_callback->o_greet_listener = NULL;
          jni_callback->z_greet_callback = NULL;
          free(jni_callback);
          jni_callback = NULL;
          
          return 0;
      }
      
    Java 层调用 native 函数
      new Greet().native_say_hello(new Greet.GreetListener() {
              @Override
              public void onGreetReceive(GreetCallback greet) {
                  Log.d(TAG, "hello, onGreetReceive: " + greet.toString());
              }
      });
    
    展开全文
  • 理解Java接口回调

    千次阅读 多人点赞 2019-02-28 13:08:27
    2、创建一个回调对象实现回调接口。 3、创建一个控制器对象,将回调对象作为参数传给控制器对象,控制器对象负责检查某个场景是否出现或某个条件是否满足,当满足时,则调用回调对象的某方法。 代码示例: 实例:...

    初步认识:

    实现步骤:

    1、创建一个回调接口。

    2、创建一个回调对象实现回调接口。

    3、创建一个控制器对象,将回调对象作为参数传给控制器对象,控制器对象负责检查某个场景是否出现或某个条件是否满足,当满足时,则调用回调对象的某方法。

    代码示例:

    实例:Boss通知员工做事情,员工完成任务之后告诉Boss完成情况。

    说明:Callback:回调接口。Boss:回调对象。Employee:控制器对象。

    1、创建一个回调接口

    public interface Callback {
    	public void yes();
    	public void no();
    }

    2、创建一个回调对象实现回调接口 

    //  Boss需要实现回调的接口
    public class Boss implements Callback{
    //	传入一个员工对象
    	private Employee employee;
    	public Boss(Employee employee) {
    		this.employee = employee;
    	}
    	
    //	告诉员工要做什么事情
    	public void doEvent(String event) {
    		System.out.println("Boss:"+event);
    //      将当前对象传给员工,员工才可以回调
    		employee.doSomething(this, event);
    	}
    	
    //	员工完成事情后回调的方法
    	@Override
    	public void yes() {
    		System.out.println("Boss:任务完成得很不错,下个月给你涨工资");
    	}
    	@Override
    	public void no() {
    		System.out.println("Boss:任务没完成,好好反思一下");
    	}
    	
    }

     3、创建一个控制器对象,将回调对象作为参数传给控制器对象,控制器对象负责检查某个场景是否出现或某个条件是否满足,当满足时,则调用回调对象的某方法

    public class Employee {
    	public Employee(){}
    
    //	完成boss交代的事情,回调接口作为参数穿过来
    	public void doSomething(Callback callback, String event) {
    		String flag=null;
    		System.out.println("Employee:正在做:"+event);
    		
    //		根据完成情况通知Boss,即接口回调
    		System.out.println("Employee:完成了任务!");
    		flag="完成";
    		if(flag.equals("完成")){
    			callback.yes();
    		}
    		
    		System.out.println("Employee:未完成任务!");
    		flag="未完成";
    		if(flag.equals("未完成")){
    			callback.no();
    		}
    		
    	}
    }

    4、测试:

    public class Test {
    	public static void main(String[] args) {
    		Employee employee=new Employee();
    		Boss boss = new Boss(employee);
    		boss.doEvent("写hello world!");
    	}
    }

    结果:

    展开全文
  • Android接口回调机制精炼详解

    万次阅读 多人点赞 2018-06-18 12:44:12
    面向接口编程是面向对象编程中的一个很重要的概念,即“接口变量存放实现该接口的类的对象的引用,从而接口变量就可以回调类中实现的接口方法”。 (2)方法的调用和方法的实现 Java中所有的方法会出现在两个地方...
  • Java接口回调详解

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

    万次阅读 多人点赞 2017-11-29 16:36:47
    接口的概念   关键字interface声明一个接口接口不是类,而是一组对类的需求描述。接口使抽象的概念更进一步,接口就像是一个成产类的工厂模具,实现类都必须按照他的要求去编译,或者说接口是建立类的协议。 ...
  • N个例子让你彻底理解java接口回调

    千次阅读 多人点赞 2017-03-23 00:17:20
    说到接口回调,对于初学者来说,理解是真的难啊,不过没有关系,看完本篇文章,你马上就能理解接口回调啦!概念什么是接口回调?用我的理解,就是:A让B去做一件耗时的操作,而且并不知道要花费多少时间,B做完了后...
  • 什么是接口回调? 1.接口回调是什么[2]? 接口回调是指:可以把使用某一接口的类创建的对象的引用赋给该接口声明的接口变量,那么该接口变量就可以调用被类实现的接口的方法。实际上,当接口变量调用被类实现的...
  • Android 关于一个接口回调的Demo

    千次下载 热门讨论 2014-09-14 20:56:44
    这里写的是一个Android接口回调的Demo,如果对接口回调不太理解、或者不太会用的话,相信看完这个简单的demo,便会解决你的问题
  • 接口回调目的和用法解析

    万次阅读 多人点赞 2018-05-05 15:18:23
    一、回调的含义和用途 1. 什么是回调 一般来说,模块之间都存在一定的调用关系,从调用方式上来看,可分为三类: 同步调用:同步调用是一种阻塞式调用,即在函数A的函数体里通过书写函数B的函数名来调用之,使...
  • 接口回调使用步骤

    千次阅读 2018-04-18 09:38:06
    *接口回调一般在什么时候用? 工具类里使用它,处理完数据之后把值存储到方法里面,在主Activity调用 * listenter方法,直接进行处理 */ //1.先创建一个接口---&amp;gt;里面写一个取得图片的方法 方法形参(需要...
  • Android两个Activity之间的接口回调

    千次阅读 2020-04-02 12:16:25
    最近在做个项目时需要在一个Activity中监听网络数据是否有更新,然后在另一个activity中更新,涉及到两个activity之间的接口回调,网上找了很多资料总算是弄出来了 首先定义一个监听接口 `public interface ...
  • Android 自定义接口回调

    千次阅读 2018-10-23 14:13:55
    1.定义一个简单的接口回调 下面是定义一个简单的接口,实现的功能是,设置名字爱好,并且返回给主 Activity。 1.1 自定义一个接口  定义一个名字为 setNameListener() 的接口类: /** * author: wu * date: ...
  • 至于定位的配置之类的我就不多说,此篇文章重点在于接口回调 private static BDAbstractLocationListener mListener = new BDAbstractLocationListener() { @Override public void onReceiveLocation...
  • 使用接口回调实现Activity的通信

    千次阅读 2018-07-05 15:27:57
    下面通过一个列子具体说说接口回调是如何实现组件通信的: 现在有这样一个需求:点击通知栏里该app的通知,点击之后需要跳转到通知详情界面。如果此时界面处于通知列表,在跳转通知详情的时候还需要刷新下该通知...
  • Java接口回调一般用法

    万次阅读 2017-03-31 20:41:38
    Java接口回调
  • 详解Android中接口回调、方法回调

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

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

    千次阅读 2018-08-21 15:51:13
    java的接口回调相信大家都用的相当熟练。不过转战到Kotlin该怎么写接口回调? 本文你会学到单参数回调,多参数回调的写法,直接上代码; /** * 文件:Test * 时间:2018/8/21. * 备注: */ class Test:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 467,265
精华内容 186,906
关键字:

接口回调