utvecklare som känner till den händelsestyrda programmeringsmodellen för MS-Windows och X Window System är vana vid att skicka funktionspekare som åberopas (det vill säga ”kallas tillbaka”) när något händer. Java: s objektorienterade modell stöder för närvarande inte metodpekare och verkar därmed utesluta att använda denna bekväma mekanism. Men allt är inte förlorat!
Java: s stöd för gränssnitt ger en mekanism genom vilken vi kan få motsvarande återuppringning. Tricket är att definiera ett enkelt gränssnitt som förklarar den metod vi vill åberopas.
Antag till exempel att vi vill bli underrättade när en händelse inträffar. Vi kan definiera ett gränssnitt:
public interface InterestingEvent{ // This is just a regular method so it can return something or // take arguments if you like. public void interestingEvent ();}
detta ger oss ett grepp om alla objekt av klasser som implementerar gränssnittet. Så vi behöver inte oroa oss för någon annan information av främmande typ. Det här är mycket trevligare än att hacka trampolin C-funktioner som använder datafältet för widgets för att hålla en objektpekare när du använder C++ – kod med Motif.
klassen som kommer att signalera händelsen måste förvänta sig objekt som implementerar InterestingEvent-gränssnittet och sedan åberopa metoden interestingEvent() efter behov.
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 (); } //... } // ...}
i det exemplet använde jag somethinghappened predikat för att spåra huruvida händelsen ska utlösas eller inte. I många fall är det faktum att metoden kallades tillräckligt för att motivera signalering av den intressanta händelsen().
koden som vill ta emot händelsemeddelandet måste implementera interface InterestingEvent och bara skicka en hänvisning till sig själv till händelsemeddelaren.
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... } //...}
Det är allt som finns till det. Jag hoppas att använda denna enkla Java idiom kommer att göra din övergång till Java lite mindre skakis.
John D. Mitchell har konsulterat för de flesta av de senaste nio åren och har utvecklat PDA-programvara på OOassembly-språk på Geoworks. Han finansierar sin Java addiction bywriting kompilatorer, Tcl / Tk, C++ och Java-System. Han medförfattare thehot nya Java book Making Sense of Javaoch utvecklar för närvarande en Java-kompilator.