Entwickler, die mit dem ereignisgesteuerten Programmiermodell von MS-Windows und dem X Window System vertraut sind, sind es gewohnt, Funktionszeiger zu übergeben, die aufgerufen werden (dh „zurückgerufen“), wenn etwas passiert. Das objektorientierte Modell von Java unterstützt derzeit keine Methodenzeiger und scheint daher die Verwendung dieses komfortablen Mechanismus auszuschließen. Aber nicht alles ist verloren!
Javas Unterstützung von Schnittstellen bietet einen Mechanismus, mit dem wir das Äquivalent von Rückrufen erhalten können. Der Trick besteht darin, eine einfache Schnittstelle zu definieren, die die Methode deklariert, die aufgerufen werden soll.
Angenommen, wir möchten benachrichtigt werden, wenn ein Ereignis eintritt. Wir können eine Schnittstelle definieren:
public interface InterestingEvent{ // This is just a regular method so it can return something or // take arguments if you like. public void interestingEvent ();}
Dies gibt uns einen Überblick über alle Objekte von Klassen, die die Schnittstelle implementieren. Wir müssen uns also nicht mit anderen fremden Informationen befassen. Dies ist viel schöner als das Hacken von C-Funktionen, die das Datenfeld von Widgets verwenden, um einen Objektzeiger zu halten, wenn C ++ – Code mit Motif verwendet wird.
Die Klasse, die das Ereignis signalisiert, muss Objekte erwarten, die die InterestingEvent-Schnittstelle implementieren, und dann die interestingEvent() -Methode aufrufen.
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 diesem Beispiel habe ich das Prädikat somethingHappened verwendet, um zu verfolgen, ob das Ereignis ausgelöst werden soll oder nicht. In vielen Fällen reicht die Tatsache, dass die Methode aufgerufen wurde, aus, um die Signalisierung von interestingEvent() zu rechtfertigen.
Der Code, der die Ereignisbenachrichtigung erhalten möchte, muss die InterestingEvent Schnittstelle implementieren und nur einen Verweis auf sich selbst an den Ereignisbenachrichter übergeben.
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... } //...}
Das ist alles. Ich hoffe, dass die Verwendung dieses einfachen Java-Idioms Ihren Übergang zu Java etwas weniger nervös macht.
John D. Mitchell, der von Koffein, Zucker und zu wenig Schlaf lebt, berät seit fast neun Jahren und hat bei Geoworks PDA-Software in OOassembly-Sprache entwickelt. Er finanziert seine Java-Sucht durch das Schreiben von Compilern, Tcl / Tk, C ++ und Java-Systemen. Er ist Mitautor des heißen neuen Java-Buches Making Sense of Java und entwickelt derzeit einen Java-Compiler.