Sempre existem essas certas interfaces entre os módulos. Do ponto de vista dos métodos de chamada, eles podem ser divididos em três categorias: chamadas síncronas, retornos de chamada e chamadas assíncronas. O seguinte se concentra em explicar o mecanismo de retorno de chamada em detalhes.
1. Visão geral
O mecanismo de retorno de chamada em Java é um mecanismo relativamente comum, mas pode ser usado menos em seu programa, e os mecanismos de retorno de chamada podem ser vistos em todos os lugares em algumas grandes estruturas. Este artigo usa alguns exemplos específicos para se aproximar lentamente do mecanismo de retorno de chamada do Java.
2. Retorno de chamada
O chamado retorno de chamada: significa chamar um método C na classe A na classe B e depois chamar o método D na classe A na classe B na classe B. Esse método d é chamado de método de retorno de chamada. Ao realmente usá -lo, haverá diferentes formulários de retorno de chamada, como os seguintes.
2.1 retornos de chamada síncronos
Aqui presumo que essa situação.
O diretor B da empresa A disse a seu subordinado (gerente de projeto C) que ele queria fazer uma pesquisa, mas C não precisava fazer isso sozinho. O gerente C pode ser solicitado a providenciar seu programador D para concluí -lo. O gerente C encontrou o programador D e disse a ele que uma tarefa de pesquisa seria concluída agora. E diga ao gerente c os resultados da pesquisa. Se houver algum problema, você ainda precisará continuar. Porque aqui está C pedindo d para fazer alguma coisa, D ainda precisa comunicar o resultado com C depois disso. Este é o modelo de retorno de chamada. A seguir, é apresentado o diagrama de aula de retorno de chamada geral:
Primeiro, precisamos ter uma interface de retorno de chamada
Callbackinterface.java
interface pública de chamada de interface {public boolean check (int resultado);} Em segundo plano, o programador D deseja comunicar os resultados com o gerente de projeto C, para que o gerente do projeto precise implementar a interface de retorno de chamada acima:
Gerente.java
Public Class Manager implementa o DallBackInterface {Programador Privado Programador = NULL; Public Manager (programador _programmer) {this.programmer = _programmer; } / *** Usado para a delegação emitida pelo chefe* / public void confrust () {arranjo (); } // agende subordinados para estudar o trabalho privado void providenciar () {System.out.println ("O gerenciador está organizando o trabalho para o programador"); Programmer.study (gerente.This); System.out.println ("O cronograma de trabalho para programador foi concluído e o gerente foi fazer outras coisas."); } @Override public boolean check (int resultado) {if (resultado == 5) {return true; } retornar false; }} Para o programador D, ele precisa realizar uma citação do gerente C para se comunicar com ele. No entanto, aqui está a tarefa que o diretor B pediu ao gerente C para organizar. Em outras palavras, outros gerentes também podem ser solicitados aqui, como os gerentes B1, B2, etc. Como os gerentes implementaram a interface de retorno de chamada, você pode permitir diretamente o programador d manter essa interface aqui. do seguinte modo:
Programador.java
public class Programmer {public void Study (retorno de chamada de interface) {int resultado = 0; do {resultado ++; System.out.println ("th" + resultado + "resultado do estudo"); } while (! Callback.check (resultado)); System.out.println ("Tarefa de pesquisa termina"); }} É ainda mais simples e claro para o diretor, porque isso é equivalente a um teste de cliente:
Boss.java
public class Boss {public static void main (string [] args) {gerente gerenciador = new Manager (new Programmer ()); gerente.entrust (); }} Resultados em execução:
O gerente está organizando o trabalho para o programador. Resultados do 1º estudo. Resultados do 2º estudo. Resultados do terceiro estudo. Resultados do 4º estudo. Resultados do 5º estudo. O 5º estudo. O trabalho de agendamento para programador foi concluído. O gerente fez outras coisas.
2.2 retornos de chamada assíncronos
Quanto ao exemplo acima, seu gerente de projeto nem sempre pode esperar pelos resultados de sua pesquisa. Mas depois de entregar essa tarefa a você, ele a ignorará. Ele fará suas próprias coisas, você fará suas próprias coisas. Portanto, a função de retorno de chamada precisa ser processada de forma assíncrona aqui.
Então, aqui precisamos modificar o código da classe do programador e modificá -lo da seguinte forma:
Programador.java
public class Programmer {public Programmer () {} public void Study (retorno de chamada de interface) {new StudyThread (retorno de chamada) .start (); } // --------------------------- Programador 正在做的工作 --------------------------- Classe StudyThread Extende o thread {CallbackInterface Callback = NULL; public StudyThread (chamada de interface _callback) {callback = _callback; } @Override public void run () {int resultado = 0; do {resultado ++; System.out.println ("th" + resultado + "resultado do estudo"); } while (! Callback.check (resultado)); System.out.println ("Tarefa de pesquisa termina"); }}}Resultados em execução:
O gerente está agendando o trabalho para programador, o trabalho de agendamento para o programador foi concluído e o gerente está fazendo outras coisas.
Resultados do 1º estudo Resultados do 2º Estudo Resultados do 3º Estudo Resultados do 4º Estudo Resultados do 5º Estudo A tarefa de pesquisa encerrou
2.3 fechamentos e retornos de chamada
Um fechamento é um objeto chamável que registra algumas informações do escopo em que foi criado.
2.3.1 Chamada normal
Primeiro, podemos ver como a chamada é feita em circunstâncias normais.
Incrementável.java
interface incrementável {void increment ();}Esta é uma interface comum (é apenas uma interface normal em chamadas comuns e é uma interface de retorno de chamada em um retorno de chamada, o que deve ser fácil de entender).
Callee1.java
classe callee1 implementa incrementável {private int i = 0; @Override public void increment () {i ++; System.out.println (i); }}Retornos de chamada.java
public class Retornos de chamada {public static void main (string [] args) {callee1 callee1 = new callee1 (); callee1.increment (); }}Os retornos de chamada é uma classe de cliente de teste, não há nada a dizer, basta olhar para o código acima.
2.3.2 teste inicial de retorno de chamada
Não há nada a dizer sobre as chamadas comuns acima, porque para um programador Java normal, isso deve ser algo que possa ser feito sem pensar.
Agora, se você deseja formar um retorno de chamada, é impossível ter apenas um callee (o objeto de retorno de chamada callee1) em termos da estrutura ou lógica do programa, e você também precisa de um objeto de chamadas. O chamador pode escrever assim:
Caller.java
classe chamador {private Incrementable RetBackReference; Caller público (incrementável _callbackReference) {callbackReference = _callbackReference; } void go () {callbackReference.Increment (); }} Aqui, o chamador contém uma referência de retorno de chamada para uma interface de retorno de chamada, assim como o programador mencionado acima precisa manter a referência de um gerente de projeto, para que você possa se comunicar com o gerente do projeto por meio dessa referência. A referência de chamada aqui também desempenha esse papel.
Agora vamos dar uma olhada na redação da aula de teste:
Retornos de chamada.java
public class Retornos de chamada {public static void main (string [] args) {callee1 callee1 = new callee1 (); CHAMADA DE CALLER1 = NOVO CHAMADA (CALLEE1); caller1.go (); }}Para o código do programa até agora, podemos comparar completamente o código acima do qual o gerente de projeto organiza os programadores para investigar problemas técnicos. Tem o mesmo efeito.
2.3.3 Retorno de chamada de fechamento
Comparado com retornos de chamada normais, o núcleo dos retornos de chamada de fechamento está naturalmente em fechamentos, ou seja, controle sobre o escopo.
Agora, suponha que um usuário (outro programador) personalize uma classe de myincrement e inclua um método de incremento. do seguinte modo:
classe myIncrement {public void increment () {System.out.println ("mycrement.increntle"); } void estático f (incremento de myincrement) {increment.Increment (); }}Há outra classe Callee2 herdada da classe acima:
classe callee2 estende myincrement {private int i = 0; public void increment () {Super.Ircrement (); i ++; System.out.println (i); }}É óbvio que, se você deseja chamar o método increment () aqui, ele se torna uma chamada de função geral. Então, aqui precisamos modificar a classe Callee2 acima. O objetivo da modificação é tornar a classe Callee2 compatível com o método increment () da classe de myincrement e o método increment () do incrementável. Após a modificação:
classe callee2 estende myincrement {private int i = 0; public void increment () {Super.Ircrement (); i ++; System.out.println (i); } classe privada Fechamento implementa incrementável {@Override public void increment () {callee2.This.Increment (); }} Incrementável getCallbackReference () {return new fechamento (); }} Observe que a classe de fechamento aqui é uma classe privada, que é um elemento de fechamento. Como a classe de fechamento é privada, deve haver uma interface aberta para operações em objetos de fechamento. Este é o método getCallbackReference () acima. A classe de chamadas não mudou.
Para testar clientes, basta olhar para o código:
public class Retornos de chamada {public static void main (string [] args) {callee2 callee2 = new callee2 (); CHAMADA DE CALLER2 = NOVO CHAMADA (CALLEE2.GETCALLBABLEFERNEFERENCE ()); caller2.go (); }}O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.