Los desarrolladores familiarizados con el modelo de programación basada en eventos de MS-Windows y el sistema X Window están acostumbrados a pasar punteros de función que se invocan (es decir, «se devuelve») cuando sucede algo. El modelo orientado a objetos de Java actualmente no admite punteros de métodos, y por lo tanto parece excluir el uso de este cómodo mecanismo. Pero no todo está perdido!
El soporte de interfaces de Java proporciona un mecanismo por el cual podemos obtener el equivalente de las devoluciones de llamada. El truco es definir una interfaz sencilla que declare el método que queremos invocar.
Por ejemplo, supongamos que queremos recibir una notificación cuando ocurre un evento. Podemos definir una interfaz:
public interface InterestingEvent{ // This is just a regular method so it can return something or // take arguments if you like. public void interestingEvent ();}
Esto nos da un control sobre cualquier objeto de las clases que implementan la interfaz. Por lo tanto, no necesitamos preocuparnos por ninguna otra información de tipo extraño. Esto es mucho mejor que piratear funciones de trampolín C que usan el campo de datos de widgets para sostener un puntero de objeto cuando se usa código C++ con Motif.
La clase que señalará el evento necesita esperar objetos que implementen la interfaz InterestingEvent y luego invoque el método interestingEvent () según corresponda.
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 (); } //... } // ...}
En ese ejemplo, usé el predicado somethingHappened para rastrear si el evento debe activarse o no. En muchos casos, el solo hecho de que se haya llamado al método es suficiente para justificar la señalización de interestingEvent().
El código que desea recibir la notificación de evento debe implementar la interfaz InterestingEvent y simplemente pasar una referencia a sí mismo al notificador de eventos.
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... } //...}
Eso es todo. Espero que el uso de este lenguaje simple de Java haga que su transición a Java sea un poco menos nerviosa.
Subsistiendo con cafeína, azúcar y muy poco sueño, John D. Mitchell ha sido consultor durante la mayor parte de los últimos nueve años, y ha desarrollado software PDA en lenguaje de ensamblaje en Geoworks. Financia su adicción a Java compiladores de escritura, Tcl / Tk, C++ y sistemas Java. Fue coautor del nuevo libro de Java Making Sense of Javay actualmente está desarrollando un compilador de Java.