Comprendere a fondo il meccanismo di callback dell'interfaccia in Android

All'inizio, non ho capito profondamente questo meccanismo, ora ristabilisco la logica. Durante lo sviluppo, l'interfaccia di callback è quella che usiamo di più.

Il significato dell'interfaccia di callback è che non viene eseguita immediatamente dopo la registrazione, ma viene eseguita in un momento opportuno.

Prima di tutto, chiarire cosa è il callback:

Facciamo un esempio: un giorno, ho chiamato per chiederti un aiuto, ovviamente una difficoltà, non hai saputo come risolverla, e non potevo aspettare lì con il telefono, quindi abbiamo stabilito: quando hai trovato una soluzione, mi chiamerai, così potrei appendere il telefono e fare altre cose. Dopo XX minuti, il mio telefono ha squillato, tu eri felice e dicevi che il problema era risolto, dovresti trattarlo così.

　

C non si chiama da solo b, l'obiettivo di C di fornire b è che S lo chiami, e C non ha scelta. S non sa cosa fornisce C, quindi S stabilisce lo standard dell'interfaccia di b (prototipo della funzione), poi C lo informa anticipatamente tramite una funzione di S chiamata r (funzione di registrazione).

In poche parole: una funzione di callback è una funzione riservata per le chiamate di sistema, e spesso sappiamo quando viene chiamata, quindi continuiamo a perfezionare la figura sopra.

Guardando questa immagine, in realtà riflettendoci, ci rendiamo conto che in vita nostra esiste ovunque questa idea di callback. Molti concetti del software sono solo una trasformazione del nostro modo di pensare nella vita reale.

La prima cosa che facciamo quando rispondiamo alle domande dell'esame è scrivere il nostro numero di matricola e nome. Ecco, scrivere il numero di matricola e nome non è per noi stessi (cioè non chiamiamo questo metodo per noi stessi), ma per i professori che registrano i punteggi (riservato per il sistema che verrà chiamato in futuro), questo è davvero un'applicazione di callback. Il professore fornisce un'interfaccia (inserisci il nome, il formato del numero di matricola), utilizziamo l'interfaccia per registrare.

Dopo aver visto questo piccolo esempio, avrete un'idea di callback, torniamo all'esempio all'inizio dell'articolo.

Quello esempio spiega lo stile di programmazione "asincrono + callback". Quando mi hai chiamato per dirmi il risultato dopo, è stato un processo di callback; il mio numero di telefono deve essere stato detto prima, questo è registrare la funzione di callback; il mio numero di telefono deve essere valido e il telefono deve essere in grado di ricevere la tua chiamata, questo è il formato che la funzione di callback deve rispettare.

Abbiamo già capito il flusso di base del callback, ora vediamo come si utilizza il callback di base in Android.

Scena uno:

Button button = (Button)this.findViewById(R.id.button);  
button.setOnClickListener(new Button.OnClickListener() {  
  // Funzione di callback  
  @Override  
  public void onClick(View v) {  
   buttonTextView.setText("Il pulsante è stato cliccato");  
  }  
});  

Il codice sopra aggiunge un listener di eventi al pulsante, che è uno dei scenari di applicazione più comuni del callback. Non chiamiamo esplicitamente il metodo onClick. Dopo che l'utente ha attivato l'evento di clic del pulsante, verrà automaticamente chiamato dal sistema Android.

Scena due:

@Override  
public void onCreate(Bundle savedInstanceState) {  
  super.onCreate(saveInstanceState);  
  // You code...  
}  
@Override  
public void onResume() {  
  super.onResume();  
  // You code...  
}  

L'intero ciclo di vita dell'Activity基本上回调函数在发挥作用。

Vediamo due dei modi di callback che utilizziamo spesso, poi facciamo una sintesi delle basi di Android utilizzando callback. In realtà, è solo una traduzione di quella nostra immagine.

--你类--

package lin.callback.test; 
public class You implements Runnable{ 
  private String who; 
   private ContactInterface callBack;  
   public You() { 
      // TODO Auto-generated constructor stub 
   } 
  //调用此方法就表示有人联系你了，注册到你这来 
   public void setCallBack(String who,String question,ContactInterface callBack) { 
     this.who = who;   
     System.out.println("你说：当前联系到我的人是"+who+"，问题是"+question); 
     this.callBack =callBack; 
   } 
   public void handleThings(){ 
     //假如你现在正在想问题的答案，需要一点时间 
     for(int i=0;i<100000;i++){  
        if(i == 0){ 
          System.out.println("你正在思考问题....."); 
        } 
     } 
     String answer = "答案是A"; 
     //想到问题的办法了 
     System.out.println("你说：想到答案了，准备打回去给"+who+"告诉他答案"); 
     callBack.callBackByTel(answer); 
   } 
  /* (non-Javadoc) 
   * @see java.lang.Runnable#run() 
   */ 
  @Override 
  public void run() { 
    try { 
      Thread.sleep(1000); 
      handleThings(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
  }  
} 

--我类--

public class Me { 
   public static void main(String[] args){  
     Me me = new Me(); 
     me.hasQuestion(); 
   } 
   private void hasQuestion(){ 
     //现在有问题想不出来答案，想去问你 
     You you = new You(); 
     you.setCallBack("蜗牛", "某道题答案是什么？", new ContactInterface() { 
      @Override 
      public void callBackByTel(String answer) { 
        System.out.println("Dico: Sì, va bene, ho ricevuto la risposta: " + answer + ", grazie"); 
      } 
    }); 
    // Ricevi una chiamata telefonica, sveglia e inizia a pensare al problema 
    new Thread(you).start(); 
   } 
} 

--Classe di interfaccia (specificazione)--

public interface ContactInterface { 
  public void callBackByTel(String answer); 
} 

Verifica dei risultati:

Dici: La persona che mi ha contattato è il ragnatela, la domanda è quale è la risposta a questa domanda?
Stai pensando al problema
Dici: Ho pensato al problema, sto per chiamare il ragnatela per dirgli la risposta
Dico: Sì, va bene, ho ricevuto la risposta: la risposta è A, grazie

Pensieri approfonditi sulla callback:

L'essenza del programma è il saltaggio del codice, indipendentemente dai metodi同步异步反射接口虚函数，essenzialmente sono chiamate di funzione. Le funzioni che dobbiamo chiamare devono avere il loro puntatore, e diversi linguaggi ottengono questo puntatore in modi diversi. Quindi, l'interfaccia che definiamo è in realtà un puntatore a funzione. Quindi, il processo di registrazione è come assegnare un valore a quel puntatore a funzione. Chiamare la funzione di implementazione definita chiamando questo puntatore a funzione.

Questo è tutto il contenuto dell'articolo. Spero che sia utile per il tuo studio e ti prego di supportare e applaudire il tutorial.

Dichiarazione: il contenuto di questo articolo è stato tratto da Internet, il copyright spetta ai rispettivi proprietari. Il contenuto è stato contribuito volontariamente dagli utenti di Internet e caricato autonomamente. Questo sito non detiene i diritti di proprietà, non è stato editato manualmente e non assume alcuna responsabilità legale. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a notice#oldtoolbag.com (al momento dell'invio, sostituisci # con @) per segnalare il problema e fornire prove pertinenti. Una volta verificata la sussistenza del problema, questo sito rimuoverà immediatamente il contenuto sospetto di violazione del copyright.