Wat is een terugbelfunctie?

Antwoord 1, autoriteit 100%

Ontwikkelaars zijn vaak in de war over wat een callback is vanwege de naam van het verdomde ding.

Een callback-functie is een functie die:

toegankelijk via een andere functie, en
wordt aangeroepen na de eerste functie als die eerste functie is voltooid

Een leuke manier om je voor te stellen hoe een callback-functie werkt, is dat het een functie is die “achteraan wordt aangeroepen” van de functie waaraan deze wordt doorgegeven.

Misschien zou een betere naam een “aanroep na”-functie zijn.

Deze constructie is erg handig voor asynchroon gedrag waarbij we willen dat een activiteit plaatsvindt wanneer een eerdere gebeurtenis is voltooid.

Pseudocode:

// 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);
}

Resultaat als je event() hebt gebeld:

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

De volgorde van de uitvoer is hier belangrijk. Omdat terugbelfuncties achteraf worden aangeroepen, wordt “Ik ben klaar met het afdrukken van nummers” als laatste afgedrukt, niet als eerste.

Callbacks worden zo genoemd vanwege hun gebruik met aanwijzertalen. Als u een van deze niet gebruikt, werk dan niet over de naam ‘terugbellen’. Begrijp gewoon dat het slechts een naam is om een methode te beschrijven die wordt geleverd als een argument voor een andere methode, zodat wanneer de bovenliggende methode wordt aangeroepen (ongeacht welke voorwaarde, zoals een klik op een knop, een timer-tick, enz.) en de hoofdtekst van de methode wordt voltooid, de callback-functie wordt dan aangeroepen.

Sommige talen ondersteunen constructies waarbij meerdere callback-functieargumenten worden ondersteund, en worden aangeroepen op basis van hoe de bovenliggende functie wordt voltooid (dwz één callback wordt aangeroepen in het geval dat de bovenliggende functie succesvol is voltooid, een andere wordt aangeroepen in het geval dat de bovenliggende functie functie genereert een specifieke fout, enz.).

Antwoord 2, autoriteit 33%

Ondoorzichtige definitie

Een callback-functie is een functie die u aan een ander stuk code geeft, zodat het door die code kan worden aangeroepen.

Gekunsteld voorbeeld

Waarom zou je dit willen doen? Laten we zeggen dat er een service is die u moet aanroepen. Als de service onmiddellijk terugkeert, hoeft u alleen maar:

Noem het
Wacht op het resultaat
Ga door zodra het resultaat binnen is

Stel bijvoorbeeld dat de service de functie factorialis. Als u de waarde van 5!wilt, roept u factorial(5)op en treden de volgende stappen op:

Je huidige uitvoeringslocatie is opgeslagen (op de stapel, maar dat is niet belangrijk)
Uitvoering wordt overgedragen aan factorial
Wanneer factorialis voltooid, wordt het resultaat ergens geplaatst waar u het kunt vinden
Uitvoering keert terug naar waar het was in [1]

Veronderstel nu dat factorialerg lang duurde, omdat je het enorme aantallen geeft en het ergens op een supercomputercluster moet draaien. Stel dat u verwacht dat het 5 minuten duurt voordat uw resultaat wordt geretourneerd. Je zou kunnen:

Behoud je ontwerp en voer je programma ‘s nachts uit als je slaapt, zodat je niet de helft van de tijd naar het scherm zit te staren
Ontwerp uw programma om andere dingen te doen terwijl factorialzijn ding doet

Als u de tweede optie kiest, is terugbellen wellicht iets voor u.

End-to-end-ontwerp

Om gebruik te kunnen maken van een terugbelpatroon, moet u factorialop de volgende manier kunnen aanroepen:

factorial(really_big_number, what_to_do_with_the_result)

De tweede parameter, what_to_do_with_the_result, is een functie die je meestuurt naar factorial, in de hoop dat factorialhet op zijn resultaat zal aanroepen alvorens terug te keren.

Ja, dit betekent dat factorialmoet zijn geschreven om terugbellen te ondersteunen.

Stel nu dat u een parameter aan uw callback wilt kunnen doorgeven. Nu kan dat niet, omdat je het niet gaat noemen, factorialwel. Dus factorialmoet worden geschreven om u in staat te stellen uw parameters door te geven, en het zal ze gewoon overhandigen aan uw callback wanneer het het aanroept. Het kan er zo uitzien:

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

Nu factorialdit patroon toestaat, kan je callback er als volgt uitzien:

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

en uw oproep naar factorialzou zijn

factorial(42, logIt, logger)

Wat als je iets wilt retourneren van logIt? Nou, dat kan niet, want factorialbesteedt er geen aandacht aan.

Nou, waarom kan factorialniet gewoon teruggeven wat je terugbelt?

Het niet-blokkerend maken

Aangezien de uitvoering bedoeld is om te worden overgedragen aan de callback wanneer factorialis voltooid, zou het echt niets moeten teruggeven aan de beller. En idealiter zou het op de een of andere manier zijn werk in een andere thread / proces / machine starten en onmiddellijk terugkeren zodat je verder kunt gaan, misschien zoiets als dit:

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

Dit is nu een “asynchrone oproep”, wat betekent dat wanneer je hem aanroept, hij onmiddellijk terugkeert, maar zijn werk nog niet echt heeft gedaan. Je hebt dus mechanismen nodig om het te controleren en om het resultaat te krijgen als het klaar is, en je programma is in het proces complexer geworden.

Trouwens, met dit patroon kan de factorial_worker_taskuw callback asynchroon starten en onmiddellijk terugkeren.

Dus wat doe je?

Het antwoord is om binnen het terugbelpatroon te blijven. Wanneer je maar wilt schrijven

a = f()
g(a)

en fasynchroon moeten worden aangeroepen, schrijf je in plaats daarvan

f(g)

waarbij gwordt doorgegeven als een callback.

Dit verandert fundamenteel de flow-topologie van je programma, en het is even wennen.

Uw programmeertaal kan u veel helpen door u een manier te bieden om functies on-the-fly te maken. In de code direct hierboven kan de functie gzo klein zijn als print (2*a+1). Als je taal vereist dat je dit als een aparte functie definieert, met een geheel onnodige naam en handtekening, dan wordt je leven onaangenaam als je dit patroon veel gebruikt.

Als je taal je daarentegen toelaat om lambda’s te maken, dan ben je in een veel betere conditie. Je zult dan iets schrijven als

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

wat zoveel leuker is.

Hoe de terugbelverzoek doorgeven

Hoe zou u de callback-functie doorgeven aan factorial? Nou, je zou het op verschillende manieren kunnen doen.

Als de aangeroepen functie in hetzelfde proces wordt uitgevoerd, kunt u een functieaanwijzer doorgeven
Of misschien wilt u een woordenboek bijhouden van fn name --> fn ptrin uw programma, in dat geval zou u de naam kunnen doorgeven
Misschien kunt u met uw taal de functie in-place definiëren, mogelijk als een lambda! Intern is het een soort object aan het maken en een aanwijzer doorgeven, maar daar hoef je je geen zorgen over te maken.
Misschien draait de functie die u aanroept op een geheel aparte machine, en roept u deze aan via een netwerkprotocol zoals HTTP. Je zou je callback kunnen laten zien als een HTTP-callable functie, en de URL ervan doorgeven.

Je snapt het idee.

De recente opkomst van callbacks

In dit webtijdperk zijn de services die we aanroepen vaak via het netwerk. We hebben vaak geen controle over die services, d.w.z. we hebben ze niet geschreven, we onderhouden ze niet, we kunnen niet garanderen dat ze werken of hoe ze presteren.

Maar we kunnen niet verwachten dat onze programma’s worden geblokkeerd terwijl we wachten tot deze services reageren. Omdat ze zich hiervan bewust zijn, ontwerpen de serviceproviders vaak API’s met behulp van het callback-patroon.

JavaScript ondersteunt callbacks heel goed, b.v. met lambda’s en sluitingen. En er is veel activiteit in de JavaScript-wereld, zowel op de browser als op de server. Er worden zelfs JavaScript-platforms ontwikkeld voor mobiel.

Naarmate we verder komen, zullen steeds meer van ons asynchrone code schrijven, waarvoor dit begrip essentieel zal zijn.

Antwoord 3, autoriteit 14%

De Callback-paginaop Wikipedia legt het heel goed uit. goed:

Bij computerprogrammering is een callback een verwijzing naar uitvoerbare code, of een stuk uitvoerbare code, dat als argument aan andere code wordt doorgegeven. Hierdoor kan een softwarelaag op een lager niveau een subroutine (of functie) oproepen die is gedefinieerd in een laag op een hoger niveau.

Antwoord 4, autoriteit 7%

Een reactie van een leek zou zijn dat het een functie is die niet door u wordt aangeroepen, maar door de gebruiker of door de browser nadat een bepaalde gebeurtenis heeft plaatsgevonden of nadat een code is verwerkt.

Antwoord 5, autoriteit 6%

Een callback-functie is een functie die moet worden aangeroepen wanneer aan een bepaalde voorwaarde is voldaan. In plaats van onmiddellijk te worden aangeroepen, wordt de callback-functie op een bepaald moment in de toekomst aangeroepen.

Meestal wordt het gebruikt wanneer een taak wordt gestart die asynchroon zal eindigen (dwz enige tijd nadat de aanroepende functie is teruggekeerd).

Voor een functie om een webpagina op te vragen, kan het bijvoorbeeld nodig zijn dat de aanroeper een terugbelfunctie geeft die wordt aangeroepen wanneer de webpagina is gedownload.

Antwoord 6, autoriteit 6%

Laten we het simpel houden. Wat is een terugbelfunctie?

Voorbeeld door gelijkenis en analogie

Ik heb een secretaresse. Elke dag vraag ik haar om: (i) de uitgaande post van het bedrijf af te geven bij het postkantoor, en nadatdat heeft gedaan, om: (ii) welke taak ik ook heb geschreven voor haar op een van die plakbriefjes.

Wat is nu de taak op het plakbriefje? De taak varieert van dag tot dag.

Stel dat ik op deze specifieke dag van haar eis dat ze enkele documenten afdrukt. Dus ik schrijf dat op het plakbriefje en speld het op haar bureau, samen met de uitgaande post die ze moet posten.

Samengevat:

eerst moet ze de post afgeven en
onmiddellijk daarnamoet ze enkele documenten afdrukken.

De terugbelfunctie is die tweede taak: het afdrukken van die documenten. Omdat het wordt gedaan NADAT de post is afgeleverd, en ook omdat het plakbriefje dat haar vertelt het document af te drukken, aan haar wordt gegeven samen met de post die ze moet posten.

Laten we dit nu koppelen aan programmeervocabulaire

De naam van de methode is in dit geval: DropOffMail.
En de terugbelfunctie is: PrintOffDocuments. De PrintOffDocuments is de terugbelfunctie omdat we willen dat de secretaresse dat doet, pas nadat DropOffMail is uitgevoerd.
Dus ik zou “doorgeven: PrintOffDocuments als een “argument” aan de DropOffMail-methode. Dit is een belangrijk punt.

Dat is alles. Niets meer. Ik hoop dat dit het voor je heeft opgehelderd – en zo niet, plaats dan een opmerking en ik zal mijn best doen om het te verduidelijken.

Antwoord 7, autoriteit 5%

Terugbellen zijn het gemakkelijkst te beschrijven in termen van het telefoonsysteem. Een functieoproep is analoog aan iemand opbellen, haar een vraag stellen, antwoord krijgen en ophangen; het toevoegen van een terugbelverzoek verandert de analogie, zodat u haar, nadat u haar een vraag heeft gesteld, ook uw naam en nummer geeft, zodat zij u kan terugbellen met het antwoord.

— Paul Jakubik, “Callback-implementaties in C++”

Antwoord 8, autoriteit 5%

Ik geloof dat dit “terugbel”-jargon op veel plaatsen ten onrechte is gebruikt. Mijn definitie zou zoiets zijn als:

Een callback-functie is een functie die u aan iemand doorgeeft en laat
ze noemen het op een bepaald moment.

Ik denk dat mensen net de eerste zin van de wiki-definitie hebben gelezen:

een callback is een verwijzing naar uitvoerbare code, of een stukje
uitvoerbare code, die als argument aan andere code wordt doorgegeven.

Ik heb met veel API’s gewerkt, zie verschillende slechte voorbeelden. Veel mensen hebben de neiging om een functieaanwijzer (een verwijzing naar uitvoerbare code) of anonieme functies (een stuk uitvoerbare code) “callback” te noemen, als het slechts functies zijn, waarom heb je hier dan een andere naam voor nodig?

Eigenlijk onthult alleen de tweede zin in de wiki-definitie de verschillen tussen een callback-functie en een normale functie:

Hierdoor kan een softwarelaag op een lager niveau een subroutine (of
functie) gedefinieerd in een laag op een hoger niveau.

dus het verschil is aan wie je de functie gaat doorgeven en hoe de functie wordt aangeroepen. Als u gewoon een functie definieert en deze doorgeeft aan een andere functie en deze rechtstreeks in die functielichaam aanroept, noem het dan geen callback. De definitie zegt dat je doorgegeven functie wordt aangeroepen door de functie “lager niveau”.

Ik hoop dat mensen kunnen stoppen met het gebruik van dit woord in een dubbelzinnige context, het kan mensen niet helpen om beter te begrijpen, alleen slechter.

Antwoord 9, autoriteit 4%

Terugbellen versus terugbelfunctie

Een Callbackis een functie die moet worden uitgevoerd nadat een andere functie is uitgevoerd vandaar de naam call back .

Wat is een Callback-functie?

Functies die Funs (d.w.z. functionele objecten) als argumenten gebruiken, of die Funs retourneren, worden functies van hogere orde genoemd.
Elke functie die als argument wordt doorgegeven, wordt een callback-functie genoemd.
een callback-functieis een functie die wordt doorgegeven aan een andere functie (laten we deze andere functie otherFunctionnoemen) als een parameter, en de callback-functie wordt aangeroepen (of uitgevoerd ) binnen de otherFunction.

   function action(x, y, callback) {
        return callback(x, y);
    }
    function multiplication(x, y) {
        return x * y;
    }
    function addition(x, y) {
        return x + y;
    }
    alert(action(10, 10, multiplication)); // output: 100
    alert(action(10, 10, addition)); // output: 20

In SOA kunnen de plug-inmodules met callback toegang krijgen tot services vanuit de container/omgeving.

Bron

Antwoord 10, autoriteit 3%

Hierdoor klinken callbacks als return-statements aan het einde van methoden.

Ik weet niet zeker of ze dat zijn.

Ik denk dat callbacks eigenlijk een aanroep van een functie zijn, als gevolg van het aanroepen en voltooien van een andere functie.

Ik denk ook dat callbacks bedoeld zijn om de oorspronkelijke invocatie aan te pakken, in een soort van “hey! dat ding waar je om vroeg? Ik heb het gedaan – ik dacht dat ik het je zou laten weten – terug naar jou”.

Antwoord 11, autoriteit 2%

Een callback-functie is een functie die u opgeeft voor een bestaande functie/methode, die moet worden aangeroepen wanneer een actie is voltooid, aanvullende verwerking vereist, enz.

In Javascript, of meer specifiek jQuery, kunt u bijvoorbeeld een callback-argument opgeven dat moet worden aangeroepen wanneer een animatie is voltooid.

In PHP kun je met de functie preg_replace_callback()een functie opgeven die wordt aangeroepen wanneer de reguliere expressie wordt gevonden, waarbij de overeenkomende tekenreeks(en) als argumenten worden doorgegeven.

Antwoord 12, autoriteit 2%

Bellen nazou een betere naam zijn dan de stomme naam, terugbellen. Wanneer of als aan een voorwaarde wordt voldaan binnen een functie, roep dan een andere functie aan, de functie Call After, de functie die als argument is ontvangen.

In plaats van een interne functie binnen een functie hard te coderen, schrijft men een functie om een reeds geschreven Call After-functie als argument te accepteren. De Call Afterkan worden aangeroepen op basis van statuswijzigingen die zijn gedetecteerd door code in de functie die het argument ontvangt.

Antwoord 13

kijk naar de afbeelding 🙂 zo werkt het

Hoofdprogramma roept de bibliotheekfunctie aan (die ook een functie op systeemniveau kan zijn) met de naam van de terugroepfunctie. Deze callback-functie kan op meerdere manieren worden geïmplementeerd. Het hoofdprogramma kiest één callback volgens vereiste.

Ten slotte roept de bibliotheekfunctie de callback-functie aan tijdens de uitvoering.

Antwoord 14

Het simpele antwoord op deze vraag is dat een callback-functie een functie is die wordt aangeroepen via een functieaanwijzer. Als je de aanwijzer (adres) van een functie als argument aan een andere doorgeeft, wordt er gezegd dat wanneer die aanwijzer wordt gebruikt om de functie aan te roepen waarnaar hij verwijst, er een terugroepactie wordt gedaan.

Antwoord 15

Stel dat we een functie hebben sort(int *arraytobesorted,void (*algorithmchosen)(void))waar het een functieaanwijzer als argument kan accepteren die op een bepaald punt in sort()‘s implementatie . Dan wordt hier de code die wordt aangesproken door de functieaanwijzer algorithmchosenaangeroepen als callback-functie.

En zie het voordeel is dat we elk algoritme kunnen kiezen zoals:

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

Die bijvoorbeeld zijn geïmplementeerd met het prototype:

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

Dit is een concept dat wordt gebruikt om polymorfisme in objectgeoriënteerd programmeren te bereiken

Antwoord 16

Bij computerprogrammering is een callback een verwijzing naar uitvoerbare code, of een stuk uitvoerbare code, dat als argument aan andere code wordt doorgegeven. Hierdoor kan een softwarelaag op een lager niveau een subroutine (of functie) oproepen die is gedefinieerd in een laag op een hoger niveau. – Wikipedia

Terugbellen in C met functieaanwijzer

In C wordt callback geïmplementeerd met behulp van Function Pointer. Functieaanwijzer – zoals de naam al doet vermoeden, is een aanwijzer naar een functie.

Bijvoorbeeld int (*ptrFunc) ();

Hier is ptrFunc een verwijzing naar een functie die geen argumenten nodig heeft en een geheel getal retourneert. Vergeet NIET tussen haakjes te zetten, anders zal de compiler aannemen dat ptrFunc een normale functienaam is, die niets nodig heeft en een pointer naar een geheel getal retourneert.

Hier is wat code om de functieaanwijzer te demonstreren.

#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;
}

Laten we nu proberen het concept van terugbellen in C te begrijpen met behulp van de functieaanwijzer.

Het volledige programma heeft drie bestanden: callback.c, reg_callback.h en 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)();                               
}

Als we dit programma uitvoeren, is de uitvoer

Dit is een programma dat de functie callback demonstreert
binnen register_callback
binnen mijn_callback
terug in het hoofdprogramma

De hogere-laagfunctie roept een lagere-laagfunctie aan als een normale aanroep en het terugbelmechanisme stelt de lagere-laagfunctie in staat om de hogere-laagfunctie aan te roepen via een aanwijzer naar een terugbelfunctie.

Terugbellen in Java via interface

Java heeft niet het concept van functieaanwijzer
Het implementeert een terugbelmechanisme via het interfacemechanisme
Hier declareren we in plaats van een functieaanwijzer een interface met een methode die wordt aangeroepen wanneer de aangeroepene zijn taak voltooit

Laat me het demonstreren aan de hand van een voorbeeld:

De terugbelinterface

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

De beller of de hogere klasse

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
}
}

De Callee of de onderste laag functie

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
}
}

Terugbellen met EventListener-patroon

Lijstitem

Dit patroon wordt gebruikt om 0 tot n aantallen waarnemers/luisteraars te informeren dat een bepaalde taak is voltooid

Lijstitem

Het verschil tussen het terugbelmechanisme en het EventListener/Observer-mechanisme is dat bij terugbellen de beller de enkele beller op de hoogte stelt, terwijl in Eventlisener/Observer de opgeroepene iedereen kan informeren die geïnteresseerd is in die gebeurtenis (de melding kan naar een andere delen van de applicatie die de taak niet hebben geactiveerd)

Laat me het uitleggen aan de hand van een voorbeeld.

De gebeurtenisinterface

public interface Events {
public void clickEvent();
public void longClickEvent();
}

Klasse-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);
    }
}

Klasse-knop

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

Klasse checkbox

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;
}
}

Activiteitsklasse

pakket com.som_itsolutions.training.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();
    }   
}

Andere klasse

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...");
}
}

Hoofdklasse

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);
}
}

Zoals je kunt zien aan de hand van de bovenstaande code, hebben we een interface met de naam evenementen die in feite alle gebeurtenissen opsomt die voor onze toepassing kunnen plaatsvinden. De Widget-klasse is de basisklasse voor alle UI-componenten zoals Button, Checkbox. Deze UI-componenten zijn de objecten die daadwerkelijk de gebeurtenissen uit de frameworkcode ontvangen. Widget-klasse implementeert de Events-interface en heeft ook twee geneste interfaces, namelijk OnClickEventListener & OnLongClickEventListener

Deze twee interfaces zijn verantwoordelijk voor het luisteren naar gebeurtenissen die kunnen optreden op de van Widget afgeleide UI-componenten zoals Button of Checkbox. Dus als we dit voorbeeld vergelijken met het eerdere Callback-voorbeeld met Java-interface, werken deze twee interfaces als de Callback-interface. Dus de code op een hoger niveau (Here Activity) implementeert deze twee interfaces. En wanneer zich een gebeurtenis voordoet in een widget, wordt de code op een hoger niveau (of de methode van deze interfaces geïmplementeerd in de code op een hoger niveau, hier Activiteit) aangeroepen.

Laat me nu het fundamentele verschil tussen callback- en eventlistener-patroon bespreken. Zoals we hebben vermeld, kan de Callee met behulp van Terugbellen slechts één enkele Beller op de hoogte stellen. Maar in het geval van het EventListener-patroon, kan elk ander deel of elke klasse van de applicatie zich registreren voor de gebeurtenissen die zich kunnen voordoen op de knop of het selectievakje. Het voorbeeld van dit soort klasse is de OtherClass. Als u de code van de OtherClass ziet, zult u zien dat deze zichzelf heeft geregistreerd als luisteraar van de ClickEvent die kan optreden in de Button die is gedefinieerd in de Activiteit. Interessant is dat, naast de Activiteit (de Beller), deze OtherClass ook op de hoogte wordt gebracht wanneer de klikgebeurtenis op de Button plaatsvindt.

Antwoord 17

Een callback is een idee om een functie als parameter door te geven aan een andere functie en deze te laten aanroepen zodra het proces is voltooid.

Als je het concept van terugbellen begrijpt door middel van geweldige antwoorden hierboven, raad ik je aan om de achtergrond van het idee te leren kennen.

“Waarom ontwikkelden ze (computerwetenschappers) terugbellen?”
Je zou een probleem kunnen leren, dat blokkeert. (vooral het blokkeren van de gebruikersinterface)
En terugbellen is niet de enige oplossing.
Er zijn veel andere oplossingen (bijv. Thread, Futures, Promises…).

Antwoord 18

Een callback-functie is een functie die u (als referentie of pointer) doorgeeft aan een bepaalde functie of object.
Deze functie of dit object roept deze functie later terug, mogelijk meerdere keren, voor welk doel dan ook:

het einde van een taak melden
vergelijking tussen twee items vragen (zoals in c qsort())
voortgang van een proces rapporteren
gebeurtenissen op de hoogte stellen
de instantie van een object delegeren
het schilderen van een gebied delegeren

…

Dus het beschrijven van een callback als een functie die wordt aangeroepen aan het einde van een andere functie of taak is te eenvoudig (zelfs als het een veelvoorkomend gebruik is).

Antwoord 19

Een belangrijk gebruiksgebied is dat u een van uw functies registreert als een handle (d.w.z. een callback) en vervolgens een bericht verzendt / een functie aanroept om wat werk of verwerking te doen. Nadat de verwerking is voltooid, roept de aangeroepen functie onze geregistreerde functie aan (d.w.z. terugbellen is voltooid), wat aangeeft dat de verwerking is voltooid.
Dezewikipedia-link legt vrij goed grafisch uit.

Antwoord 20

Een callback-functie, ook wel een functie van hogere orde genoemd, is een functie die als parameter aan een andere functie wordt doorgegeven, en de callback-functie wordt aangeroepen (of uitgevoerd) binnen de bovenliggende functie.

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

Hier hebben we een functie als parameter doorgegeven aan de click-methode. En de klikmethode zal de callback-functie aanroepen (of uitvoeren) die we eraan hebben doorgegeven.

Antwoord 21

Terugbelfunctie
Een functie die als argument aan een andere functie is doorgegeven.

function test_function(){       
 alert("Hello world");  
} 
setTimeout(test_function, 2000);

Opmerking:In het bovenstaande voorbeeld wordt test_function gebruikt als argument voor de functie setTimeout.