Siempre hay estas ciertas interfaces entre módulos. Desde la perspectiva de los métodos de llamadas, se pueden dividir en tres categorías: llamadas sincrónicas, devoluciones de llamada y llamadas asincrónicas. A continuación se centra en explicar el mecanismo de devolución de llamada en detalle.
1. Descripción general
El mecanismo de devolución de llamada en Java es un mecanismo relativamente común, pero puede usarse menos en su programa, y los mecanismos de devolución de llamada se pueden ver en todas partes en algunos marcos grandes. Este artículo utiliza algunos ejemplos específicos para acercarse lentamente al mecanismo de devolución de llamada de Java.
2. Devolución de llamada
La llamada devolución de llamada: significa llamar a un método C en la Clase A en la Clase B, y luego llamar al Método D en la Clase A en la Clase B en la Clase B. Este método D se denomina método de devolución de llamada. Cuando realmente lo use, habrá diferentes formularios de devolución de llamada, como los siguientes.
2.1 devoluciones de llamada sincrónicas
Aquí supongo tal situación.
El Director B de la Compañía A le dijo a su subordinado (Gerente del Proyecto C) que quería hacer una encuesta, pero que C no necesitaba hacerlo él mismo. Se puede pedir al gerente C que haga arreglos para que su programador D lo complete. El gerente C encontró el programador D y le dijo que ahora se completaría una tarea de investigación. Y dígale al gerente c los resultados de la encuesta. Si hay algún problema, aún tiene que continuar. Debido a que aquí está C pidiendo D que haga algo, D todavía tiene que comunicar el resultado con C después de eso. Este es el modelo de devolución de llamada. El siguiente es el diagrama general de la clase de devolución de llamada:
Primero necesitamos tener una interfaz de devolución de llamada de devolución de llamada
Callbackinterface.java
Interfaz pública CallbackInterface {Public Boolean Check (int resultado);} En el fondo, el Programador D desea comunicar los resultados con Project Manager C, por lo que el administrador de proyectos debe implementar la interfaz de devolución de llamada anterior:
Gerente.java
Public Class Manager implementa CallbackInterface {Programador privado programador = nulo; Public Manager (programador _programmer) {this.programmer = _programmer; } / *** utilizado para la delegación emitida por el jefe* / public void encust () {arreglo (); } // programar subordinados para estudiar trabajo privado void arregle () {system.out.println ("El gerente está organizando trabajo para el programador"); programador.study (gerente.this); System.out.println ("El cronograma de trabajo para el programador se ha completado, y el gerente se ha ido a hacer otras cosas"); } @Override public boolean check (int resultado) {if (resultado == 5) {return true; } return false; }} Para el Programador D, necesita tener una cita del Gerente C para comunicarse con él. Sin embargo, aquí está la tarea que el Director B pidió al Gerente C que organizara. En otras palabras, también se puede preguntar a otros gerentes aquí, como los gerentes B1, B2, etc. Debido a que los gerentes han implementado la interfaz de devolución de llamada, puede dejar que el programador D mantenga esta interfaz aquí. como sigue:
Programador.java
Programador de clase pública {Estudio público void (devocación de callbackInterface) {int result = 0; do {resultado ++; System.out.println ("th" + resultado + "resultado del estudio"); } while (! callback.eck (resultado)); System.out.println ("La tarea de encuesta termina"); }} Es aún más simple y claro para el director, porque esto es equivalente a una prueba de cliente:
Jefe.java
Public Class Boss {public static void main (string [] args) {gerente gerente = nuevo administrador (nuevo programador ()); gerente.entrust (); }} Resultados de ejecución:
El gerente está organizando trabajo para programador. Resultados del primer estudio. Resultados del segundo estudio. Resultados del tercer estudio. Resultados del cuarto estudio. Resultados del quinto estudio. El quinto estudio. Se ha completado el trabajo de programación para el programador. El gerente ha hecho otras cosas.
2.2 devoluciones de llamada asincrónicas
En cuanto al ejemplo anterior, su gerente de proyecto no siempre puede esperar los resultados de su investigación. Pero después de que le entregue esta tarea, él la ignorará. Él hará lo suyo, harás lo tuyo. Por lo tanto, la función de devolución de llamada debe procesarse de manera asincrónica aquí.
Entonces, aquí necesitamos modificar el código de la clase de programador y modificarlo de la siguiente manera:
Programador.java
Public Class Programmer {Public Programmer () {} Public void Study (CallbackInterface Callback) {New StudyThread (Callback) .Start (); } // --------------------- Public StudyThread (CallbackInterface _Callback) {Callback = _Callback; } @Override public void run () {int resultado = 0; do {resultado ++; System.out.println ("th" + resultado + "resultado del estudio"); } while (! callback.eck (resultado)); System.out.println ("La tarea de encuesta termina"); }}}Resultados de ejecución:
El gerente está programando el trabajo para programador. Se ha completado el trabajo de programación para programador, y el administrador está haciendo otras cosas.
Resultados del primer estudio Resultados del segundo estudio Resultados de los resultados del tercer estudio de los resultados del cuarto estudio del 5º estudio que terminó la tarea de investigación.
2.3 cierres y devoluciones de llamada
Un cierre es un objeto invocable que registra alguna información del alcance en el que se creó.
2.3.1 Llamada normal
Primero, podemos ver cómo se realiza la llamada en circunstancias normales.
Incrementable.java
interfaz incrementable {void increment ();}Esta es una interfaz ordinaria (es solo una interfaz normal en las llamadas ordinarias, y es una interfaz de devolución de llamada en una devolución de llamada, que debería ser fácil de entender).
Callee1.java
clase Callee1 implementa incrementable {private int i = 0; @Override public void increment () {i ++; System.out.println (i); }}Devolución de llamada.java
Callbacks de clase pública {public static void main (string [] args) {callee1 callee1 = new callee1 (); callee1.increment (); }}Callbacks es una clase de cliente de prueba, no hay nada que decir, solo mire el código anterior.
2.3.2 Prueba inicial de devolución de llamada
No hay nada que decir sobre las llamadas ordinarias anteriores, porque para un programador Java normal, esto debería ser algo que se pueda hacer sin pensar.
Ahora, si desea formar una devolución de llamada, es imposible tener solo una Callee (el objeto de devolución de llamada Callee1) en términos de la estructura o lógica del programa, y también necesita un objeto de llamadas. La persona que llama puede escribirlo así:
Llamador.java
clase Llamador {CallbackReference de devolución de llamada incrementable privada; Public Caller (incrementable _callbackReference) {callbackReference = _callbackReference; } void go () {callbackReference.Increment (); }} Aquí Caller posee una referencia de devolución de llamada para una interfaz de devolución de llamada, al igual que el programador mencionado anteriormente necesita tener la referencia de un administrador de proyectos, para que pueda comunicarse con el administrador del proyecto a través de esta referencia. La referencia de devolución de llamada aquí también juega este papel.
Ahora echemos un vistazo a la escritura de la clase de prueba:
Devolución de llamada.java
Callbacks de clase pública {public static void main (string [] args) {callee1 callee1 = new callee1 (); Llamador llamador1 = nuevo llamador (Callee1); caller1.go (); }}Para el código del programa hasta el momento, podemos comparar completamente el código por encima del cual el gerente del proyecto organiza a los programadores para investigar los problemas técnicos. Tiene el mismo efecto.
2.3.3 Caller Callback
En comparación con las devoluciones de llamada normales, el núcleo de las devoluciones de llamada de cierre está naturalmente en cierres, es decir, control sobre el alcance.
Ahora suponga que un usuario (otro programador) personaliza una clase de MyIncrement e incluye un método de incremento. como sigue:
class myIncrement {public void increment () {System.out.println ("mycrement.increment"); } void estático f (incremento myincement) {increment.increment (); }}Hay otra clase Callee2 heredada de la clase anterior:
clase callee2 extiende myincrement {private int i = 0; public void increment () {super.Increment (); i ++; System.out.println (i); }}Es obvio que si desea llamar al método increment () aquí, se convierte en una llamada de función general. Así que aquí necesitamos modificar la clase Callee2 anterior. El objetivo de la modificación es hacer que la clase Callee2 sea compatible con el método increment () de la clase Myincrement y el método increment () del incrementable. Después de la modificación:
clase callee2 extiende myincrement {private int i = 0; public void increment () {super.Increment (); i ++; System.out.println (i); } El cierre de clase privada implementa incrementable {@Override public void increment () {callee2.this.increment (); }} Incrementable getCallBackReference () {return nuevo cierre (); }} Tenga en cuenta que la clase de cierre aquí es una clase privada, que es un elemento de un cierre. Debido a que la clase de cierre es privada, debe haber una interfaz abierta para las operaciones en objetos de cierre. Este es el método GetCallBackReference () anterior. La clase de llamadas no ha cambiado.
Para probar clientes, solo mire el código:
Backbacks de clase pública {public static void main (string [] args) {callee2 callee2 = new callee2 (); Llamador llamador2 = new Caller (callee22.getCallbackReference ()); caller2.Go (); }}Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.