Detailed code explanation of callback mechanism

This article mainly introduces the relevant information about the detailed explanation of java callback mechanism examples. Friends who need it can refer to it

Detailed explanation of java callback mechanism examples

I didn’t understand it before What is a callback? I hear people talking about adding a callback method every day, and I wonder, what is a callback method? Then I searched and searched on the Internet. I searched a lot but didn't understand it very well. Now I know, the so-called callback: it means that class A calls a certain method C in class B, and then class B in turn calls a method C in class A. Method D. This method D is called the callback method. If you look like this, you may feel a little dizzy. In fact, I didn’t understand it at the beginning either. I read what others said about the more classic callback method:

• Class A implements interface CallBack callback——Background 1

• class A Contains a reference to class B b ——Background 2

• class B has a method f(CallBack callback) with a parameter of callback — —Background 3

• A’s objecta calls B’s method f (CallBack callback) ——Class A calls someone of class B Method C

• Then b can call A's method in the f (CallBack callback) method - class B calls a certain method of class A D

Everyone likes to use the example of making a phone call. Well, in order to keep up with the times, I will also use this example. My example uses asynchronous plus callback

One day Xiao Wang met a It was a difficult question. The question was "1 + 1 = ?", so I called Xiao Li and asked him. Xiao Li didn't know it at all, so he told Xiao Wang that he would think about the answer after I finish the things at hand. , Xiao Wang would not stupidly hold the phone and wait for Xiao Li's answer, so Xiao Wang said to Xiao Li, I still want to go shopping. If you know the answer, call me and tell me, so he hung up the phone. , do your own thing. After an hour, Xiao Li called Xiao Wang and told him that the answer was 2

/** 
 * 这是一个回调接口 
 * @author xiaanming 
 * 
 */ 
public interface CallBack { 
 /** 
  * 这个是小李知道答案时要调用的函数告诉小王，也就是回调函数 
  * @param result 是答案 
  */ 
 public void solve(String result); 
}

/** 
 * 这个是小王 
 * @author xiaanming 
 * 实现了一个回调接口CallBack，相当于----->背景一 
 */ 
public class Wang implements CallBack { 
 /** 
  * 小李对象的引用 
  * 相当于----->背景二 
  */ 
 private Li li; 
 
 /** 
  * 小王的构造方法，持有小李的引用 
  * @param li 
  */ 
 public Wang(Li li){ 
  this.li = li; 
 } 
  
 /** 
  * 小王通过这个方法去问小李的问题 
  * @param question 就是小王要问的问题,1 + 1 = ? 
  */ 
 public void askQuestion(final String question){ 
  //这里用一个线程就是异步， 
  new Thread(new Runnable() { 
   @Override 
   public void run() { 
    /** 
     * 小王调用小李中的方法，在这里注册回调接口 
     * 这就相当于A类调用B的方法C 
     */ 
    li.executeMessage(Wang.this, question); 
   } 
  }).start(); 
   
  //小网问完问题挂掉电话就去干其他的事情了，诳街去了 
  play(); 
 } 
 
 public void play(){ 
  System.out.println("我要逛街去了"); 
 } 
 
 /** 
  * 小李知道答案后调用此方法告诉小王，就是所谓的小王的回调方法 
  */ 
 @Override 
 public void solve(String result) { 
  System.out.println("小李告诉小王的答案是--->" + result); 
 } 
  
}

/** 
 * 这个就是小李啦 
 * @author xiaanming 
 * 
 */ 
public class Li { 
 /** 
  * 相当于B类有参数为CallBack callBack的f()---->背景三 
  * @param callBack 
  * @param question 小王问的问题 
  */ 
 public void executeMessage(CallBack callBack, String question){ 
  System.out.println("小王问的问题--->" + question); 
   
  //模拟小李办自己的事情需要很长时间 
  for(int i=0; i<10000;i++){ 
    
  } 
   
  /** 
   * 小李办完自己的事情之后想到了答案是2 
   */ 
  String result = "答案是2"; 
   
  /** 
   * 于是就打电话告诉小王，调用小王中的方法 
   * 这就相当于B类反过来调用A的方法D 
   */ 
  callBack.solve(result);  
 } 
}

/** 
 * 测试类 
 * @author xiaanming 
 * 
 */ 
public class Test { 
 public static void main(String[]args){ 
  /** 
   * new 一个小李 
   */ 
  Li li = new Li(); 
 
  /** 
   * new 一个小王 
   */ 
  Wang wang = new Wang(li); 
   
  /** 
   * 小王问小李问题 
   */ 
  wang.askQuestion("1 + 1 = ?"); 
 } 
}

Have you almost understood the callback mechanism through the above example? The above is An asynchronous callback, let's take a look at the synchronous callback, onClick() method
Now let's analyze the click method onclick() of Android View; we know that onclick() is A callback method, this method is executed when the user clicks the View. Let’s use Button as an example.

//这个是View的一个回调接口 
/** 
 * 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); 
}

package com.example.demoactivity; 
 
import android.app.Activity; 
import android.os.Bundle; 
import android.view.View; 
import android.view.View.OnClickListener; 
import android.widget.Button; 
import android.widget.Toast; 
 
/** 
 * 这个就相当于Class A 
 * @author xiaanming 
 * 实现了 OnClickListener接口---->背景一 
 */ 
public class MainActivity extends Activity implements OnClickListener{ 
 /** 
  * Class A 包含Class B的引用----->背景二 
  */ 
 private Button button; 
 
 @Override 
 public void onCreate(Bundle savedInstanceState) { 
  super.onCreate(savedInstanceState); 
  setContentView(R.layout.activity_main); 
  button = (Button)findViewById(R.id.button1); 
   
  /** 
   * Class A 调用View的方法,而Button extends View----->A类调用B类的某个方法 C 
   */ 
  button.setOnClickListener(this); 
 } 
 
 /** 
  * 用户点击Button时调用的回调函数，你可以做你要做的事 
  * 这里我做的是用Toast提示OnClick 
  */ 
 @Override 
 public void onClick(View v) { 
  Toast.makeText(getApplication(), "OnClick", Toast.LENGTH_LONG).show(); 
 } 
 
}

The following is the setOnClickListener method of the View class, which is equivalent to Class B. Only the key code is posted.

/** 
 * 这个View就相当于B类 
 * @author xiaanming 
 * 
 */ 
public class View implements Drawable.Callback, KeyEvent.Callback, AccessibilityEventSource { 
 /** 
  * Listener used to dispatch click events. 
  * This field should be made private, so it is hidden from the SDK. 
  * {@hide} 
  */ 
 protected OnClickListener mOnClickListener; 
  
 /** 
  * setOnClickListener()的参数是OnClickListener接口------>背景三 
  * Register a callback to be invoked when this view is clicked. If this view is not 
  * clickable, it becomes clickable. 
  * 
  * @param l The callback that will run 
  * 
  * @see #setClickable(boolean) 
  */ 
  
 public void setOnClickListener(OnClickListener l) { 
  if (!isClickable()) { 
   setClickable(true); 
  } 
  mOnClickListener = l; 
 } 
  
  
 /** 
  * Call this view's OnClickListener, if it is defined. 
  * 
  * @return True there was an assigned OnClickListener that was called, false 
  *   otherwise is returned. 
  */ 
 public boolean performClick() { 
  sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED); 
 
  if (mOnClickListener != null) { 
   playSoundEffect(SoundEffectConstants.CLICK); 
    
   //这个不就是相当于B类调用A类的某个方法D，这个D就是所谓的回调方法咯 
   mOnClickListener.onClick(this); 
   return true; 
  } 
 
  return false; 
 } 
}

This example is the typical callback mechanism of Android. After reading this, do you have a better understanding of the callback mechanism? Thread run() is also a callback method. When the start() method of Thread is executed, the run() method will be called back. It is also more classic to process messages, etc.

[Related recommendations]

1. Java Free Video Tutorial

2. Alibaba Java Development Manual

3. Geek Academy Java Video tutorial

The above is the detailed content of Detailed code explanation of callback mechanism. For more information, please follow other related articles on the PHP Chinese website!