Developers conversant in the event-driven programming model of MS-Windows and The X Window System are accustomed to passing function pointers that are invocated (that is, “called back”) when something happens. O modelo orientado a objetos do Java não suporta ponteiros de método, e assim parece excluir o uso deste mecanismo confortável. Mas nem tudo está perdido!
o Suporte de interfaces Java fornece um mecanismo pelo qual podemos obter o equivalente de callbacks. O truque é definir uma interface simples que declare o método que queremos ser invocados.Por exemplo, suponha que queremos ser notificados quando um evento acontece. Podemos definir uma interface:
public interface InterestingEvent{ // This is just a regular method so it can return something or // take arguments if you like. public void interestingEvent ();}
isso nos dá um controle sobre quaisquer objetos de classes que implementam a interface. Portanto, não precisamos nos preocupar com qualquer outro tipo de informação externa. Isto é muito melhor do que hackear funções de C trampolim que usam o campo de dados de widgets para manter um ponteiro de objeto ao usar o código C++ com motivos.
a classe que irá sinalizar o evento precisa esperar objetos que implementem a interface interessante e então invocar o método interestingEvent() conforme apropriado.
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 (); } //... } // ...}
nesse exemplo, eu usei o predicado de algumas coisas para rastrear se o evento deve ou não ser desencadeado. Em muitos casos, o próprio fato de que o método foi chamado é suficiente para justificar a sinalização do interesse().
o código que deseja receber a notificação do evento deve implementar a interface interessante do evento e apenas passar uma referência a si mesmo para o notificador do 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... } //...}
é tudo o que há para ele. Espero que usar este idioma Java simples faça sua transição para Java um pouco menos nervosa.Subsisting on cafeína, sugar, and too little sleep, John D. Mitchell has been consulting for most of the last nine years, and has developed PDA software in Ooassembly language at Geoworks. Ele financia seu vício em Java escrevendo Compiladores, Tcl / Tk, C++ e sistemas Java. Ele co-autor do novo Java book que faz sentido para Javaand está atualmente desenvolvendo um compilador Java.