Consejo 10 de Java: Implemente rutinas de devolución de llamada en Java

Los desarrolladores familiarizados con el modelo de programación dirigida por eventos de MS-Windows y el sistema X Window están acostumbrados a pasar punteros de función que se invocan (es decir, "devueltos") cuando sucede algo. El modelo orientado a objetos de Java no admite actualmente punteros de método y, por tanto, parece excluir el uso de este cómodo mecanismo. ¡Pero no todo está perdido!

El soporte de interfaces de Java proporciona un mecanismo mediante el cual podemos obtener el equivalente de devoluciones de llamada. El truco consiste en definir una interfaz sencilla que declare el método que deseamos invocar.

Por ejemplo, supongamos que queremos ser notificados cuando ocurre un evento. Podemos definir una interfaz:

public interface InterestingEvent {// Este es solo un método regular por lo que puede devolver algo o // tomar argumentos si lo desea. public void interesanteEvento (); }

Esto nos da un control sobre los objetos de las clases que implementan la interfaz. Por lo tanto, no debemos preocuparnos por ningún otro tipo de información extraña. Esto es mucho más agradable que hackear funciones C de trampolín que usan el campo de datos de los widgets para sostener un puntero de objeto cuando se usa código C ++ con Motif.

La clase que señalará el evento debe esperar objetos que implementen la interfaz InterestingEvent y luego invocar el método interesanteEvent () según corresponda.

public class EventNotifier {private InterestingEvent es decir; private boolean somethingHappened; public EventNotifier (InterestingEvent event) {// Guarde el objeto de evento para su uso posterior. es decir = evento; // No hay nada que informar todavía. somethingHappened = falso; } // ... public void doWork () {// Verifica el predicado, que está configurado en otro lugar. if (somethingHappened) {// Señala el par invocando el método de la interfaz. es decir, interesanteEvento (); } // ...} // ...}

En ese ejemplo, utilicé el predicado somethingHappened para rastrear si el evento debería activarse o no. En muchos casos, el mero hecho de que se haya llamado al método es suficiente para justificar la señalización del evento interesante () .

El código que desea recibir la notificación del evento debe implementar la interfaz InterestingEvent y simplemente pasar una referencia a sí mismo al notificador del evento.

La clase pública CallMe implementa InterestingEvent {private EventNotifier en; public CallMe () {// Creamos el notificador de eventos y pasamos nosotros mismos a él. en = new EventNotifier (esto); } // Define el controlador real del evento. public void interesanteEvento () {// ¡Guau! ¡Debe haber ocurrido algo realmente interesante! // Hacer algo... } //... }

Eso es todo al respecto. Espero que usar este sencillo modismo de Java hará que su transición a Java sea un poco menos nerviosa.

Sobreviviendo con cafeína, azúcar y muy poco sueño, John D. Mitchell ha estado consultando durante la mayor parte de los últimos nueve años y ha desarrollado software PDA en lenguaje ensamblador OO en Geoworks. Financia su adicción a Java escribiendo compiladores, sistemas Tcl / Tk, C ++ y Java. Fue coautor del nuevo libro de Java Making Sense of Java y actualmente está desarrollando un compilador de Java.

Esta historia, "Consejo 10 de Java: Implementar rutinas de devolución de llamada en Java" fue publicada originalmente por JavaWorld.