les développeurs sont souvent confus par ce qu'est un rappel à cause du nom de la chose maudite.

une fonction de rappel est une fonction qui est:

• accessible par une autre fonction, et
• est invoqué après la première fonction si cette première fonction complète

Une belle façon d'imaginer comment une fonction de rappel fonctionne, c'est que c'est une fonction qui est " appelé à l'arrière " de la fonction qu'il est passé.

peut-être qu'un meilleur nom serait une fonction " call after " .

cette construction est très utile pour le comportement asynchrone où nous voulons qu'une activité ait lieu chaque fois qu'un événement précédent se termine.

Pseudo:

// A function which accepts another function as an argument
// (and will automatically invoke that function when it completes - note that there is no explicit call to callbackFunction)
funct printANumber(int number, funct callbackFunction) {
    printout("The number you provided is: " + number);
}

// a function which we will use in a driver function as a callback function
funct printFinishMessage() {
    printout("I have finished printing numbers.");
}

// Driver method
funct event() {
   printANumber(6, printFinishMessage);
}

résultat si vous avez appelé event ():

The number you provided is: 6
I have finished printing numbers.

l'ordre de la sortie est ici important. Puisque les fonctions de rappel sont appelées par la suite, "j'ai fini d'imprimer des numéros" est imprimé en dernier, pas en premier.

Callbacks sont soi-disant en raison de leur utilisation avec les langues de pointeur. Si vous n'en utilisez pas, n'utilisez pas le nom "callback". Juste comprendre que c'est juste un nom pour décrire une méthode qui est fourni comme argument à une autre méthode, tel que lorsque le parent la méthode est appelée (quelle que soit la condition, tel qu'un clic de bouton, une minuterie etc) et son corps de méthode complète, la fonction de rappel est alors invoquée.

certaines langues prennent en charge des constructions où plusieurs arguments de fonction de rappel sont pris en charge, et sont appelées en fonction de la façon dont la fonction mère se termine (c'est-à-dire qu'une fonction de rappel est appelée dans le cas où la fonction mère se termine avec succès, une autre est appelée dans le cas où la fonction mère déclenche une erreur spécifique, etc.)

Définition Opaque

une fonction de rappel est une fonction que vous fournissez à un autre morceau de code, permettant qu'il soit appelé par ce code.

exemple artificiel

Pourquoi voulez-vous faire ça? Disons qu'il y a un service que vous devez invoquer. Si le service revient immédiatement, vous venez de:

1. Appeler
2. attendre le résultat
3. Continue dès que le résultat arrive en

par exemple, supposons que le service soit la fonction factorial . Lorsque vous voulez la valeur de 5! , vous invoquerez factorial(5) , et les étapes suivantes se produiront:

1. votre emplacement d'exécution actuel est sauvegardé (sur la pile, mais ce n'est pas important) "

2. L'exécution est confiée à factorial

3. quand factorial complète, il met le résultat quelque part où vous pouvez l'obtenir

4. L'exécution reprend là où elle était dans [1]

maintenant supposez que factorial a pris un temps vraiment long, parce que vous lui donnez des nombres énormes et il a besoin de fonctionner sur un certain cluster de supercalculateurs somewhere. Disons que vous vous attendez à prendre 5 minutes pour retournez votre résultat. Vous pourriez:

1. Gardez votre conception et exécutez votre programme la nuit quand vous êtes endormi, de sorte que vous ne regardez pas l'écran la moitié du temps

2. concevoir votre programme pour faire d'autres choses tandis que factorial fait son truc

si vous choisissez la deuxième option, alors les callbacks pourraient fonctionner pour vous.

Conception de bout en bout

afin d'exploiter un modèle de rappel, ce que vous voulez est de pouvoir appeler factorial de la manière suivante:

factorial(really_big_number, what_to_do_with_the_result)

Le deuxième paramètre, what_to_do_with_the_result , est une fonction que vous envoyez à factorial , dans l'espoir que factorial va l'appeler sur son résultat avant de retourner.

Oui, cela signifie que factorial doit avoir été écrit à l'appui de rappels.

supposons maintenant que vous voulez pouvoir passer un paramètre à votre callback. Maintenant, vous ne pouvez pas, parce que vous n'allez pas à l'appeler, factorial est. Donc factorial doit être écrit pour vous permettre de passer vos paramètres, et il suffit de les remettre à votre rappel quand il l'invoque. Il pourrait ressembler à ceci:

factorial (number, callback, params)
{
    result = number!   // i can make up operators in my pseudocode
    callback (result, params)
}

maintenant que factorial autorise ce modèle, votre rappel pourrait ressembler à ceci:

logIt (number, logger)
{
    logger.log(number)
}

et votre appel à factorial serait

factorial(42, logIt, logger)

Que faire si vous voulez retourner quelque chose de logIt ? Tu ne peux pas, parce que factorial n'y prête pas attention.

Eh bien, pourquoi factorial ne peut pas simplement retourner ce que votre callback retourne?

, ce qui rend non-blocage

puisque l'exécution est censée être remise à la callback quand factorial est terminé, il ne devrait vraiment rien retourner à son appelant. Et idéalement, il lancerait son travail dans un autre thread / process / machine et reviendrait immédiatement pour que vous puissiez continuer, peut-être quelque chose comme ceci:

factorial(param_1, param_2, ...)
{
    new factorial_worker_task(param_1, param_2, ...);
    return;
}

il s'agit maintenant d'un" appel asynchrone", ce qui signifie que lorsque vous l'appelez, il retourne immédiatement mais n'a pas vraiment fait son travail encore. Si vous avez besoin de mécanismes pour vérifier sur lui, et d'obtenir son résultat lorsque c'est terminé, et votre programme est devenu plus complexe dans le processus.

et par ailleurs, en utilisant ce modèle le factorial_worker_task peut lancer votre rappel asynchrone et revenir immédiatement.

Alors que faites-vous?

la réponse est de rester dans le schéma de rappel. Chaque fois que vous voulez écrire

a = f()
g(a)

et f doit être appelé asynchrone, vous écrirez à la place

f(g)

où g est passé comme un rappel.

cela change fondamentalement le flux-topologie de votre programme , et il faut s'y habituer.

Votre langage de programmation pourrait vous aider beaucoup en vous donnant un moyen de créer des fonctions à la volée. Dans le code immédiatement au-dessus, la fonction g peut être aussi petite que print (2*a+1) . Si votre langue exige que vous définissiez ceci comme une fonction séparée, avec un nom et une signature entièrement inutile, alors votre vie va devenir désagréable si vous utilisez ce modèle beaucoup.

si, d'un autre côté, votre langue vous permet de créer lambdas, alors vous êtes en bien meilleure forme. Vous finirez par écrire quelque chose comme

f( func(a) { print(2*a+1); })

ce qui est tellement mieux.

Comment passer de la fonction de rappel

Comment passer le fonction de rappel à factorial ? Eh bien, vous pourriez le faire dans un certain nombre de façons.

1. si la fonction appelée est en cours d'exécution dans le même processus, vous pouvez passer un pointeur de fonction

2. ou peut-être voulez-vous maintenir un dictionnaire de fn name --> fn ptr dans votre programme, auquel cas vous pourriez passer le nom

3. peut-être que votre langue vous permet de définir fonction en place, possible comme lambda! À l'intérieur, c'est créer une sorte d'objet et passer un pointeur, mais vous n'avez pas à vous soucier de cela.

4. peut-être que la fonction que vous appelez tourne sur une machine entièrement séparée, et vous l'appelez en utilisant un protocole réseau comme HTTP. Vous pouvez exposer votre callback comme une fonction HTTP-callable, et passer son URL.

vous avez l'idée.

La hausse récente des rappels

dans cette ère web que nous avons saisie, les services que nous invoquons sont souvent sur le réseau. Souvent, nous n'avons aucun contrôle sur ces services, c'est-à-dire que nous ne les avons pas rédigés, nous ne les maintenons pas, nous ne pouvons pas nous assurer qu'ils sont en place ou qu'ils fonctionnent bien.

mais nous ne pouvons pas nous attendre à ce que nos programmes bloquent en attendant que ces services répondent. Conscients de cela, les fournisseurs de services souvent concevoir des API en utilisant le modèle de rappel.

JavaScript supporte très bien les callbacks par exemple avec lambdas et les fermetures. Et il y a beaucoup d'activité dans le monde JavaScript, tant sur le navigateur que sur le serveur. Il existe même des plateformes JavaScript développées pour mobile.

à mesure Que nous avançons, plus nous serons écrire du code asynchrone, pour qui cette compréhension est indispensable.

notez que callback est un mot.

la page de rappel de wikipedia l'explique très bien.

citation de la page wikipedia:

dans la programmation informatique, un callback est une référence à un code exécutable, ou un morceau de code exécutable, qui est passé comme argument à un autre code. Cela permet à une couche logicielle de niveau inférieur d'appeler un sous-programme (ou une fonction) défini dans une couche supérieure.

Un profane réponse serait que c'est une fonction qui n'est pas appelé par vous, mais plutôt par l'utilisateur ou par le navigateur après un certain événement s'est produit ou après une partie du code a été traitée.

Une fonction de rappel est celui qui doit être appelée lorsqu'une certaine condition est remplie. Au lieu d'être appelé immédiatement, la fonction de rappel est appelée à un certain moment dans l'avenir.

typiquement, il est utilisé quand une tâche est commencée qui se terminera asynchrone (c'est-à-dire se terminera un certain temps après que la fonction d'appel est revenue).

par exemple, une fonction pour demander une page Web pourrait exiger que son appelant fournisse un rappel fonction qui sera appelée lorsque la page Web a terminé le téléchargement.

je crois que ce jargon" callback " a été utilisé par erreur dans beaucoup d'endroits. Ma définition serait quelque chose comme:

une fonction de rappel est une fonction que vous passez à quelqu'un et laissez leur appel à un certain point du temps.

je pense que les gens viennent de lire la première phrase de la définition du wiki:

un callback est une référence à un code exécutable, ou un morceau de code exécutable, qui est transmis comme argument à un autre code.

j'ai travaillé avec beaucoup d'Api, voir divers de mauvais exemples. Beaucoup de gens ont tendance à nommer un pointeur de fonction (une référence au code exécutable) ou des fonctions anonymes(un morceau de code exécutable) "callback", si ce sont juste des fonctions pourquoi avez-vous besoin d'un autre nom pour cela?

en fait, seule la deuxième phrase dans la définition wiki révèle les différences entre un rappel fonction et une fonction normale:

cela permet à une couche logicielle de niveau inférieur d'appeler un sous-programme (ou fonction) défini dans une couche de niveau supérieur.

donc la différence est qui vous allez passer la fonction et comment votre passé en fonction va être appelé. Si vous définissez juste une fonction et la passez à une autre fonction et l'appelez directement dans ce corps de fonction, ne l'appelez pas un callback. La définition dit votre fonction passée sera appelée par "fonction de niveau inférieur".

j'espère que les gens peuvent arrêter d'utiliser ce mot dans un contexte ambigu, il ne peut pas aider les gens à mieux comprendre que pire.

les Callbacks sont plus faciles à décrire en termes de système téléphonique. Un appel de fonction est analogue à appeler quelqu'un au téléphone, lui poser une question, obtenir une réponse, et raccrocher; ajouter un rappel modifie l'analogie de sorte qu'après lui avoir posé une question, vous lui donnez aussi votre nom et votre numéro afin qu'elle puisse vous rappeler avec la réponse.

-- Paul Jakubik, "Rappel des Implémentations en C++"

soyons simples. Qu'est ce qu'un retour d'appel de la fonction?

exemple par parabole et par analogie

j'ai une secrétaire. Tous les jours, je lui demande: (i) de déposer le courrier sortant de la société au bureau de poste, et après elle a fait cela, à faire: (ii) quelle que soit la tâche que j'ai écrit pour elle sur l'un de ces sticky notes .

maintenant, ce qui est la tâche sur la note-collant? La tâche varie de jour en jour.

supposez que ce jour-là, j'exige qu'elle imprime des documents. Alors, j'ai écrit en bas de la note, et je l'épingler sur son bureau avec le courrier sortant, elle doit afficher.

en résumé:

1. d'abord, elle doit déposer le courrier et
2. immédiatement après ce qui est fait, elle a besoin pour imprimer certains documents.

la fonction de rappel est la deuxième tâche: imprimer ces documents. Parce que c'est fait après que le courrier est déposé, et aussi parce que la note collante lui disant d'imprimer le document lui est donnée avec le courrier dont elle a besoin à la plupart.

associons maintenant cela au vocabulaire de programmation

• le nom de la méthode dans ce cas est: DropOffMail.
• et la fonction de rappel est: PrintOffDocuments. La fonction PrintOffDocuments est la fonction call back parce que nous voulons que le secrétaire le fasse, seulement après que DropOffMail a été lancé.
• donc je passerais: PrintOffDocuments comme un "argument" à la méthode DropOffMail. C'est un point important.

C'est tout. Rien de plus. J'espère que effacée pour vous - et si pas, poster un commentaire et je vais le faire de mon mieux pour clarifier.

cela rend les callbacks sonores comme des déclarations de retour à la fin des méthodes.

Je ne suis pas sûr que ce soit ce qu'ils soient.

je pense que les Callbacks sont en fait un appel à une fonction, en conséquence d'une autre fonction étant invoquée et achevée.

je pense aussi que les Callbacks sont destinés à traiter l'invocation d'origine, dans une sorte de " hey! cette chose que vous avez demandé? Je l'ai fait - j'ai juste pensé que je vous le ferais savoir - retour de plus pour vous".

une fonction de rappel est une fonction que vous spécifiez à une fonction/méthode existante, à invoquer lorsqu'une action est terminée, nécessite un traitement supplémentaire, etc.

en Javascript, ou plus spécifiquement jQuery, par exemple, vous pouvez spécifier un argument de callback à appeler lorsqu'une animation est terminée.

en PHP, la fonction preg_replace_callback() vous permet de fournir une fonction qui sera appelée lorsque l'expression régulière est appariée, passer la chaîne(S) correspond à des arguments.

Appel Après serait un meilleur nom que le nom stupide, rappel . Quand ou si la condition est remplie dans une fonction, Appelez une autre fonction, la fonction appeler après , celle reçue comme argument.

plutôt qu'un code dur une fonction interne au sein d'une fonction, on écrit une fonction pour accepter un déjà écrit appel après fonction comme argument. Le Appel après peut être appelé basé sur des changements d'état détectés par le code dans la fonction recevant l'argument.

regardez l'image :)

programme principal appelle la fonction de bibliothèque (qui peut être aussi une fonction au niveau du système) avec le nom de la fonction de rappel. Cette fonction de rappel peut être implémentée de plusieurs façons. Le programme principal choisit un rappel selon les exigences.

enfin, la fonction bibliothèque appelle la fonction callback lors de l'exécution.

la réponse simple à cette question Est qu'une fonction de rappel est une fonction qui est appelée par un pointeur de fonction. Si vous passez le pointeur (l'adresse) d'une fonction comme argument d'une autre, lorsque le pointeur est utilisé pour appeler la fonction, il souligne qu'il est dit qu'un retour d'appel est fait

suppose que nous avons une fonction sort(int *arraytobesorted,void (*algorithmchosen)(void)) où il peut accepter un pointeur de fonction comme son argument qui peut être utilisé à un certain point dans sort() l 'implémentation . Puis, ici, le code qui est traité par le pointeur de fonction algorithmchosen est appelé fonction de rappel .

et voir l'avantage est que nous pouvons choisir n'importe quel algorithme comme:

  1.    algorithmchosen = bubblesort
  2.    algorithmchosen = heapsort
  3.    algorithmchosen = mergesort   ...

qui ont été,disons, mis en œuvre avec le prototype:

  1.   `void bubblesort(void)`
  2.   `void heapsort(void)`
  3.   `void mergesort(void)`   ...

c'est un concept utilisé pour atteindre le polymorphisme dans la programmation orientée objet

Qu'est-ce que callback ?

• en général, un appel téléphonique fait pour retourner un appel que quelqu'un a reçu.
• En informatique, un rappel est un morceau de code exécutable, qui est passé comme argument à un autre code. Quand la fonction est terminée avec son travail (ou quand un événement s'est produit), elle appelle votre fonction de rappel (elle vous rappelle - d'où le nom).

Qu'est-ce qu'un fonction de rappel ?

• une fonction de rappel est comme un serviteur qui "rappelle" son maître lorsqu'il a terminé une tâche.

• a fonction de rappel est une fonction qui est passée à une autre fonction (appelons cette autre fonction otherFunction ) comme paramètre, et la fonction de rappel est appelé (ou exécuté) à l'intérieur du otherFunction .

  fonction action (x, y, callback) ) { Rappel de retour(x, y); }

  multiplication de fonction(x, y) { return x * y; }

  ajout de fonction (x, y) { retour x + y; }

  alert (action (10, 10, multiplication)); / / output: 100

  alert(d'action(10, 10, ajout)); // sortie: 20

dans SOA, callback permet aux Modules Plugin d'accéder aux services à partir du conteneur/environnement.

Analogie: Callbacks. Asynchrone. Non-blocage

exemple de rappel dans la vie réelle

"Dans la programmation informatique, un rappel est une référence au code de l'exécutable, ou un morceau de code exécutable, qui est passé comme un argument à l'autre code. Cela permet à une couche logicielle de niveau inférieur d'appeler un sous-programme (ou une fonction) défini dans une couche de niveau supérieur."- Wikipedia

Callback en C utilisant le pointeur de fonction

en C, le rappel est implémenté en utilisant le pointeur de fonction. Pointeur de fonction - comme son nom l' l'indique, est un pointeur vers une fonction.

par exemple, int (*ptrFunc) ();

ici, ptrFunc est un pointeur vers une fonction qui ne prend aucun argument et renvoie un entier. N'oubliez pas de mettre la parenthèse, sinon le compilateur supposera que ptrFunc est un nom de fonction normal, qui ne prend rien et renvoie un pointeur à un entier.

voici du code pour montrer le pointeur de fonction.

#include<stdio.h>
int func(int, int);
int main(void)
{
    int result1,result2;
    /* declaring a pointer to a function which takes
       two int arguments and returns an integer as result */
    int (*ptrFunc)(int,int);

    /* assigning ptrFunc to func's address */                    
    ptrFunc=func;

    /* calling func() through explicit dereference */
    result1 = (*ptrFunc)(10,20);

    /* calling func() through implicit dereference */        
    result2 = ptrFunc(10,20);            
    printf("result1 = %d result2 = %d\n",result1,result2);
    return 0;
}

int func(int x, int y)
{
    return x+y;
}

essayons maintenant de comprendre le concept de Callback en C en utilisant le pointeur de fonction.

Le programme complet a trois fichiers: rappel.c, reg_callback.h et reg_callback.C.

/* callback.c */
#include<stdio.h>
#include"reg_callback.h"

/* callback function definition goes here */
void my_callback(void)
{
    printf("inside my_callback\n");
}

int main(void)
{
    /* initialize function pointer to
    my_callback */
    callback ptr_my_callback=my_callback;                        
    printf("This is a program demonstrating function callback\n");
    /* register our callback function */
    register_callback(ptr_my_callback);                          
    printf("back inside main program\n");
    return 0;
}

/* reg_callback.h */
typedef void (*callback)(void);
void register_callback(callback ptr_reg_callback);


/* reg_callback.c */
#include<stdio.h>
#include"reg_callback.h"

/* registration goes here */
void register_callback(callback ptr_reg_callback)
{
    printf("inside register_callback\n");
    /* calling our callback function my_callback */
    (*ptr_reg_callback)();                               
}

si nous exécutons ce programme, le résultat sera

Ceci est un programme démontrant la fonction callback à l'intérieur de register_callback à l'intérieur de my_callback retour au programme principal

le la fonction de couche supérieure appelle une fonction de couche inférieure comme un appel normal et le mécanisme de rappel permet à la fonction de couche inférieure d'appeler la fonction de couche supérieure par un pointeur vers une fonction de rappel.

Callback en Java utilisant L'Interface

Java n'a pas le concept de pointeur de fonction Il implémente le mécanisme de rappel par le biais de son mécanisme D'Interface Ici, au lieu d'un pointeur de fonction, nous déclarons une Interface ayant une méthode qui sera appelé lorsque la callee termine sa tâche

Permettez-moi de le démontrer par un exemple:

L'Interface De Rappel

public interface Callback
{
    public void notify(Result result);
}

l'Appelant ou Le Niveau Plus élevé de la Classe

public Class Caller implements Callback
{
Callee ce = new Callee(this); //pass self to the callee

//Other functionality
//Call the Asynctask
ce.doAsynctask();

public void notify(Result result){
//Got the result after the callee has finished the task
//Can do whatever i want with the result
}
}

Le Destinataire de l'appel ou de la couche inférieure de la fonction

public Class Callee {
Callback cb;
Callee(Callback cb){
this.cb = cb;
}

doAsynctask(){
//do the long running task
//get the result
cb.notify(result);//after the task is completed, notify the caller
}
}

Callback utilisant le motif EventListener

• article de la liste

Ce modèle est utilisé pour notifier 0 à n nombres D'observateurs / auditeurs qu'une tâche particulière a terminé

• article de la liste

la différence entre le mécanisme de rappel et le mécanisme Evenlistener/Observer est que dans le callback, le destinataire de l'appel avertit le seul appelant, alors que dans le cas D'un demandeur / Observateur, l'appelant peut notifier toute personne intéressée par cet événement (la notification peut aller à d'autres parties de la demande qui n'ont pas déclenché la tâche)

permettez-moi de l'expliquer par un exemple.

L'Interface D'Événement

public interface Events {

public void clickEvent();
public void longClickEvent();
}

Class Widget

package com.som_itsolutions.training.java.exampleeventlistener;

import java.util.ArrayList;
import java.util.Iterator;

public class Widget implements Events{

    ArrayList<OnClickEventListener> mClickEventListener = new ArrayList<OnClickEventListener>(); 
    ArrayList<OnLongClickEventListener> mLongClickEventListener = new ArrayList<OnLongClickEventListener>();

    @Override
    public void clickEvent() {
        // TODO Auto-generated method stub
        Iterator<OnClickEventListener> it = mClickEventListener.iterator();
                while(it.hasNext()){
                    OnClickEventListener li = it.next();
                    li.onClick(this);
                }   
    }
    @Override
    public void longClickEvent() {
        // TODO Auto-generated method stub
        Iterator<OnLongClickEventListener> it = mLongClickEventListener.iterator();
        while(it.hasNext()){
            OnLongClickEventListener li = it.next();
            li.onLongClick(this);
        }

    }

    public interface OnClickEventListener
    {
        public void onClick (Widget source);
    }

    public interface OnLongClickEventListener
    {
        public void onLongClick (Widget source);
    }

    public void setOnClickEventListner(OnClickEventListener li){
        mClickEventListener.add(li);
    }
    public void setOnLongClickEventListner(OnLongClickEventListener li){
        mLongClickEventListener.add(li);
    }
}

public class Button extends Widget{
private String mButtonText;
public Button (){
} 
public String getButtonText() {
return mButtonText;
}
public void setButtonText(String buttonText) {
this.mButtonText = buttonText;
}
}

Case À Cocher De La Classe

public class CheckBox extends Widget{
private boolean checked;
public CheckBox() {
checked = false;
}
public boolean isChecked(){
return (checked == true);
}
public void setCheck(boolean checked){
this.checked = checked;
}
}

Classe D'Activité

package com.som_itsolutions.formation.Java.exampleeventlistener;

public class Activity implements Widget.OnClickEventListener
{
    public Button mButton;
    public CheckBox mCheckBox;
    private static Activity mActivityHandler;
    public static Activity getActivityHandle(){
        return mActivityHandler;
    }
    public Activity ()
    {
        mActivityHandler = this;
        mButton = new Button();
        mButton.setOnClickEventListner(this);
        mCheckBox = new CheckBox();
        mCheckBox.setOnClickEventListner(this);
        } 
    public void onClick (Widget source)
    {
        if(source == mButton){
            mButton.setButtonText("Thank you for clicking me...");
            System.out.println(((Button) mButton).getButtonText());
        }
        if(source == mCheckBox){
            if(mCheckBox.isChecked()==false){
                mCheckBox.setCheck(true);
                System.out.println("The checkbox is checked...");
            }
            else{
                mCheckBox.setCheck(false);
                System.out.println("The checkbox is not checked...");
            }       
        }
    }
    public void doSomeWork(Widget source){
        source.clickEvent();
    }   
}

Autre Classe

public class OtherClass implements Widget.OnClickEventListener{
Button mButton;
public OtherClass(){
mButton = Activity.getActivityHandle().mButton;
mButton.setOnClickEventListner(this);//interested in the click event                        //of the button
}
@Override
public void onClick(Widget source) {
if(source == mButton){
System.out.println("Other Class has also received the event notification...");
}
}

Classe Principale

public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Activity a = new Activity();
OtherClass o = new OtherClass();
a.doSomeWork(a.mButton);
a.doSomeWork(a.mCheckBox);
}
}

As vous pouvez voir à partir du code ci-dessus, que nous avons une interface appelée events qui répertorie essentiellement tous les événements qui peuvent se produire pour notre application. La classe Widget est la classe de base pour tous les composants de L'interface utilisateur comme Button, Checkbox. Ces composants UI sont les objets qui reçoivent effectivement les événements du code framework. La classe Widget implémente l'interface Events et elle a aussi deux interfaces imbriquées à savoir OnClickEventListener & OnLongClickEventListener

ces deux interfaces sont responsables de l'écoute des événements qui peuvent se produire sur les composants D'interface dérivés des widgets comme Button ou Checkbox. Donc, si nous comparons cet exemple avec L'exemple de rappel précédent en utilisant L'Interface Java, ces deux interfaces fonctionnent comme l'interface de rappel. Donc le code de niveau supérieur (ici activité) implémente ces deux interfaces. Et chaque fois qu'un événement se produit à un widget, le code de niveau supérieur (ou la méthode de ces interfaces implémentée dans le code de niveau supérieur, qui est ici De l'activité) sera appelée.

permettez-moi maintenant de discuter de la différence fondamentale entre le rappel et le motif Eventilistener. Comme nous l'avons mentionné, en utilisant le service de rappel, l'appelant ne peut aviser qu'un seul appelant. Mais dans le cas D'EventListener pattern, toute autre partie ou classe de l'Application peut s'enregistrer pour les événements qui peuvent se produire sur le bouton ou la case à cocher. L'exemple de ce type de classe est L'Autreclasse. Si vous voyez le code de L'Autreclasse, vous constaterez qu'il a s'est enregistré comme un auditeur du ClickEvent qui peut se produire dans le bouton défini dans l'activité. Ce qui est intéressant, c'est que, en plus de L'activité ( L'appelant), cette Autreclasse sera également avertie chaque fois que l'événement de clic se produit sur le bouton.

une zone d'utilisation importante est que vous enregistrez une de vos fonctions comme une poignée (c.-à-d. un rappel) et ensuite envoyer un message / appeler une fonction pour faire un travail ou un traitement. Maintenant que le traitement est terminé, la fonction appelée appellerait notre fonction enregistrée (c'est-à-dire que maintenant le rappel est terminé), indiquant ainsi que le traitement us est terminé.

ce lien sur wikipedia explique très bien graphiquement.

une fonction de rappel, également appelée fonction d'ordre supérieur, est une fonction qui est transmise à une autre fonction en tant que paramètre, et la fonction de rappel est appelée (ou exécutée) à l'intérieur de la fonction mère.

$("#button_1").click(function() {
  alert("button 1 Clicked");
});

ici, nous avons passé une fonction comme paramètre à la méthode click. Et la méthode click appellera (ou exécutera) la fonction callback que nous lui avons transmise.

Fonction De Rappel Une fonction qui passe à une autre fonction comme argument.

function test_function(){       
 alert("Hello world");  
} 

setTimeout(test_function, 2000);

Note: dans l'exemple ci-dessus test_function utilisé comme argument pour la fonction setTimeout.

une fonction de rappel est une fonction que vous passez (comme une référence ou un pointeur) à une certaine fonction ou objet. Cette fonction ou cet objet rappellera cette fonction à tout moment plus tard, peut-être plusieurs fois, pour tout type d'utilisation:

• notification de la fin d'une tâche
• demande de comparaison entre deux articles (comme dans C qsort ())
• le rapport d'étape d'un processus de
• notification d'événements
• délégation de l'instanciation d'un objet
• déléguer la peinture d'une zone

...

ainsi, décrire un callback comme une fonction appelée à la fin d'une autre fonction ou tâche est excessivement simplifié (même si c'est un cas d'usage courant).