ontwikkelaars die vertrouwd zijn met het event-driven programming model van MS-Windows en het X Window systeem zijn gewend aan het doorgeven van functie pointers die worden aangeroepen (dat wil zeggen, “teruggeroepen”) wanneer er iets gebeurt. Java ‘ s object-georiënteerde model ondersteunt momenteel geen methode pointers, en lijkt dus het gebruik van dit comfortabele mechanisme uit te sluiten. Maar niet alles is verloren!
Java ‘ s ondersteuning van interfaces biedt een mechanisme waarmee we het equivalent van callbacks kunnen krijgen. De truc is om een eenvoudige interface te definiëren die de methode aangeeft die we willen gebruiken.
bijvoorbeeld, stel dat we op de hoogte willen worden gebracht wanneer een gebeurtenis plaatsvindt. We kunnen een interface definiëren:
public interface InterestingEvent{ // This is just a regular method so it can return something or // take arguments if you like. public void interestingEvent ();}
dit geeft ons grip op alle objecten van klassen die de interface implementeren. We hoeven ons dus geen zorgen te maken over andere vreemde informatie. Dit is veel mooier dan het hacken van trampoline C functies die het gegevensveld van widgets gebruiken om een object pointer te houden bij het gebruik van C++ code met Motif.
de klasse die de gebeurtenis signaleert, moet objecten verwachten die de InterestingEvent interface implementeren en vervolgens de interestingEvent() methode aanroepen, indien van toepassing.
public class EventNotifier{ private InterestingEvent ie; private boolean somethingHappened; public EventNotifier (InterestingEvent event) { // Save the event object for later use. ie = event; // Nothing to report yet. somethingHappened = false; } //... public void doWork () { // Check the predicate, which is set elsewhere. if (somethingHappened) { // Signal the even by invoking the interface's method. ie.interestingEvent (); } //... } // ...}
in dat voorbeeld gebruikte ik het ’thinghappened’ predicaat om bij te houden of de gebeurtenis al dan niet zou moeten worden geactiveerd. In veel gevallen is het feit dat de methode werd aangeroepen voldoende om het signaleren van de interestingEvent () te rechtvaardigen.
de code die de gebeurtenismelding wenst te ontvangen, moet de InterestingEvent interface implementeren en alleen een verwijzing naar zichzelf doorgeven aan de gebeurtenismelding.
public class CallMe implements InterestingEvent{ private EventNotifier en; public CallMe () { // Create the event notifier and pass ourself to it. en = new EventNotifier (this); } // Define the actual handler for the event. public void interestingEvent () { // Wow! Something really interesting must have occurred! // Do something... } //...}
dat is alles. Ik hoop dat het gebruik van deze eenvoudige Java idioom zal uw overgang naar Java Een beetje minder zenuwachtig.John D. Mitchell, werkzaam op het gebied van cafeïne, suiker en te weinig slaap, adviseert het grootste deel van de laatste negen jaar en heeft bij Geoworks PDA-software in OOassembly taal ontwikkeld. Hij financiert zijn Java-verslaving door compilers, Tcl/Tk, C++ en Java-systemen te schrijven. Hij was medeauteur van dehot New Java book Making Sense of Java en is momenteel bezig met het ontwikkelen van een Java compiler.