Gli sviluppatori che conoscono il modello di programmazione event-driven di MS-Windows e il sistema X Window sono abituati a passare puntatori di funzione che vengono invocati (cioè “richiamati”) quando succede qualcosa. Il modello orientato agli oggetti di Java attualmente non supporta i puntatori ai metodi e sembra quindi precludere l’utilizzo di questo comodo meccanismo. Ma non tutto è perduto!
Il supporto delle interfacce di Java fornisce un meccanismo attraverso il quale possiamo ottenere l’equivalente dei callback. Il trucco è definire una semplice interfaccia che dichiari il metodo che vogliamo essere invocato.
Ad esempio, supponiamo di voler essere avvisati quando si verifica un evento. Possiamo definire un’interfaccia:
public interface InterestingEvent{ // This is just a regular method so it can return something or // take arguments if you like. public void interestingEvent ();}
Questo ci dà una presa su qualsiasi oggetto di classi che implementano l’interfaccia. Quindi, non dobbiamo preoccuparci di altre informazioni di tipo estraneo. Questo è molto più bello di hacking trampolino C funzioni che utilizzano il campo dati dei widget per tenere un puntatore oggetto quando si utilizza il codice C++ con Motif.
La classe che segnalerà l’evento deve aspettarsi oggetti che implementano l’interfaccia InterestingEvent e quindi invocare il metodo interestingEvent() come appropriato.
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 questo esempio, ho usato il predicato somethingHappened per tenere traccia se l’evento deve essere attivato o meno. In molti casi, il fatto stesso che il metodo sia stato chiamato è sufficiente a giustificare la segnalazione di interestingEvent ().
Il codice che desidera ricevere la notifica dell’evento deve implementare l’interfaccia InterestingEvent e passare semplicemente un riferimento a se stesso al notificatore dell’evento.
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... } //...}
Questo è tutto quello che c’è da fare. Spero che usare questo semplice linguaggio Java renderà la tua transizione a Java un po ‘ meno nervosa.
Sussistendo su caffeina, zucchero e troppo poco sonno, John D. Mitchell ha consultato per la maggior parte degli ultimi nove anni e ha sviluppato software PDA in linguaggio OOassembly presso Geoworks. Finanzia la sua dipendenza da Java scrivendo compilatori, Tcl / Tk, C++ e sistemi Java. Ha coautore del nuovo libro Java Making Sense of Javae sta attualmente sviluppando un compilatore Java.