Les développeurs connaissant le modèle de programmation événementielle de MS-Windows et du système X Window sont habitués à passer des pointeurs de fonction qui sont invoqués (c’est-à-dire « rappelés ») lorsque quelque chose se produit. Le modèle orienté objet de Java ne prend actuellement pas en charge les pointeurs de méthode et semble donc empêcher l’utilisation de ce mécanisme confortable. Mais tout n’est pas perdu !
La prise en charge des interfaces par Java fournit un mécanisme par lequel nous pouvons obtenir l’équivalent des rappels. L’astuce consiste à définir une interface simple qui déclare la méthode que nous souhaitons invoquer.
Par exemple, supposons que nous souhaitions être avertis lorsqu’un événement se produit. Nous pouvons définir une interface:
public interface InterestingEvent{ // This is just a regular method so it can return something or // take arguments if you like. public void interestingEvent ();}
Cela nous donne une prise sur tous les objets des classes qui implémentent l’interface. Nous n’avons donc pas besoin de nous préoccuper d’autres informations de type étrangères. C’est beaucoup plus agréable que de pirater les fonctions C de trampoline qui utilisent le champ de données des widgets pour contenir un pointeur d’objet lors de l’utilisation de code C ++ avec Motif.
La classe qui signalera l’événement doit attendre des objets qui implémentent l’interface InteressingEvent, puis invoquer la méthode interessingEvent() selon le cas.
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 (); } //... } // ...}
Dans cet exemple, j’ai utilisé le prédicat somethingHappened pour savoir si l’événement devait être déclenché ou non. Dans de nombreux cas, le fait même que la méthode ait été appelée suffit à justifier la signalisation de l’interestingEvent().
Le code qui souhaite recevoir la notification d’événement doit implémenter l’interface InterestingEvent et se transmettre simplement une référence au notifiant d’événement.
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... } //...}
C’est tout ce qu’il y a à faire. J’espère que l’utilisation de cet idiome Java simple rendra votre transition vers Java un peu moins nerveuse.
Souffrant de caféine, de sucre et de trop peu de sommeil, John D. Mitchell est consultant depuis la plupart des neuf dernières années et a développé un logiciel PDA en langage OOassembly chez Geoworks. Il finance sa dépendance à Java en écrivant des compilateurs, des systèmes Tcl/Tk, C++ et Java. Il a coauteur du nouveau livre Java hot Making Sense of Javaet développe actuellement un compilateur Java.