Prefácio
Recentemente, aprendi Java e entrei em contato com o mecanismo de retorno de chamada (retorno de chamada). Quando me conheci, senti -me bastante confuso e as explicações relevantes que procurei on -line foram mencionadas ou disseram simplesmente, como se tivesse definido retorno de chamada. É claro que, depois que entendi o retorno de chamada, fui ler as várias explicações on -line e não houve problema. No entanto, para mim, que é iniciante, não tenho um processo gradual.
O retorno de chamada é um modo de chamada de mão dupla. O que isso significa? Ou seja, a parte chamada também ligará para a outra parte quando é chamada , que é chamada de retorno de chamada. "Se você me ligar, eu ligarei de volta".
Não entende? Não importa, primeiro dê uma olhada nesta maneira clássica de usar retornos de chamada:
Interface de implementos de classe A INA - Background 1
A classe A contém uma referência B da classe B - fundo 2
Classe B tem um método com parâmetro INA Test (INA A) - Antecedentes 3
Objeto A de A chama o método de B para si mesmo, teste (a) - esta etapa é equivalente a você me chama
Então B pode chamar o método INA no método de teste - esta etapa é equivalente a eu ligar de volta
Antes de começar, imagine um cenário: as crianças do jardim de infância acabaram de aprender a mais em 10.
Abaixo, descreverei meu entendimento pessoal do mecanismo de retorno de chamada na ordem de raso ao profundo. Se houver alguma inadequação, espero te dar conselhos!
Capítulo 1. A origem da história
O professor do jardim de infância escreveu uma fórmula "1 + 1 =" no quadro -negro, e Xiao Ming preencheria os espaços em branco.
Desde que aprendi a adição de menos de 10, Xiao Ming pode calcular essa questão inteiramente por si mesmo. O código para simular o processo é o seguinte:
public class Student {private string name = null; Public Student (Nome da String) {// TODO Construtor Auto-Gerado Stub this.name = Name; } public void setName (nome da string) {this.name = name; } private int calcAdd (int a, int b) {return a + b; } public void FillBlank (int a, int b) {int resultado = calcAdd (a, b); System.out.println (nome + "aritmética mental:" + a + " +" + b + "=" + resultado); }} Quando Xiao Ming estava preenchendo os espaços em branco , ele calculou diretamente o Clacadd e descobriu que o resultado era 2 e escreveu o resultado no espaço. O código de teste é o seguinte:
classe pública teste {public static void main (string [] args) {int a = 1; int b = 1; Estudante s = novo aluno ("Xiao Ming"); s.fillblank (a, b); }} Os resultados da operação são os seguintes:
A aritmética mental de Xiao Ming: 1 + 1 = 2
Esse processo é feito inteiramente pelo objeto de instância apenas da aula do aluno e não envolve um mecanismo de retorno de chamada.
Capítulo 2. A busca por problemas para professores de jardim de infância
Durante o intervalo, o professor do jardim de infância de repente teve um capricho e escreveu "168 + 291 =" no quadro -negro para deixar Xiao Ming completar e depois voltou ao escritório.
Esfreamento de flores! Por que todos os professores não podem se dar bem com Xiao Ming? Está obviamente além das regras, ok? Neste momento, Xiao Ming obviamente não conseguiu concluí -lo por aritmética mental como a acima. Quando ele estava confuso, Xiao Hong na classe entregou uma calculadora que só poderia calcular a adição (um lucro)! ! ! ! Xiao Ming sabe como usar uma calculadora, então ele calculou os resultados através da calculadora e concluiu o preenchimento em branco.
O código da calculadora é:
calculadora pública da classe {public int add (int a, int b) {return a + b; }} Modifique a aula do aluno e adicione um método para usar a calculadora:
public class Student {private string name = null; Public Student (Nome da String) {// TODO Construtor Auto-Gerado Stub this.name = Name; } public void setName (nome da string) {this.name = name; } @Suppresswarnings ("não utilizado") privado int calcadd (int a, int b) {return a + b; } private int usecalculator (int a, int b) {return new calculator (). add (a, b); } public void Fillblank (int a, int b) {int resultado = usecalculator (a, b); System.out.println (nome + "use calculadora:" + a + " +" + b + "=" + resultado); }} O código de teste é o seguinte:
classe pública teste {public static void main (string [] args) {int a = 168; int b = 291; Estudante s = novo aluno ("Xiao Ming"); s.fillblank (a, b); }} Os resultados da operação são os seguintes:
Xiao Ming usa calculadora: 168 + 291 = 459
O mecanismo de retorno de chamada não esteve envolvido nesse processo, mas alguns dos trabalhos de Xiao Ming foram transferidos e serão auxiliados pela calculadora.
3. O professor do jardim de infância está de volta
Quando descobri que Xiao Ming havia completado a adição de 3 dígitos, o professor pensou que Xiao Ming era muito inteligente e um talento maleável. Então, ele escreveu "26549 + 16487 =" no quadro-negro, pedindo a Xiao Ming para completar os preenchimentos antes da aula e depois retornou ao escritório.
Xiao Ming olhou para o amiguinho que estava se divertindo fora da sala de aula e não pôde deixar de se sentir triste. Se você não sair para jogar, esse intervalo será arruinado! ! ! ! Olhando para a calculadora que Xiaohong o entregou novamente, Xiao Ming criou um plano: vamos Xiaohong fazer isso por ele.
Xiao Ming disse a Xiaohong que a pergunta era "26549 + 16487 =", depois apontou o local específico para preencher os resultados e depois saiu para se divertir.
Aqui, não implementamos o Xiaohong sozinho, mas consideramos esta calculadora que só pode calcular a adição e o Xiaohong como um todo, uma super calculadora que pode calcular os resultados e preencher os espaços em branco. Os parâmetros que essa super calculadora precisa passar são as duas adições e a posição para preencher os espaços em branco, e esses conteúdos precisam ser informados com antecedência, ou seja, Xiao Ming deseja expor parte de seus métodos a Xiao Hong. A maneira mais fácil é contar a Xiao Hong sua referência e as duas adições juntas.
Portanto, o método ADD do supercalculador deve conter dois operandos e uma referência ao próprio Xiao Ming, o código é o seguinte:
classe pública supercalculator {public void add (int a, int b, aluno xiaoming) {int resultado = a + b; xiaoming.fillblank (a, b, resultado); }} Xiao Ming não precisa mais de aritmética ou calculadora mental, então ele só precisa ter um método para pedir ajuda a Xiaohong. O código é o seguinte:
public class Student {private string name = null; Public Student (Nome da String) {// TODO Construtor Auto-Gerado Stub this.name = Name; } public void setName (nome da string) {this.name = name; } public void calhelp (int a, int b) {new supercalculator (). add (a, b, this); } public void Fillblank (int a, int b, int resultado) {System.out.println (nome + "buscando o cálculo xiaohong:" + a + " +" + b + "=" + resultado); }} O código de teste é o seguinte:
classe pública teste {public static void main (string [] args) {int a = 26549; int b = 16487; Estudante s = novo aluno ("Xiao Ming"); S.Callhelp (A, B); }} O resultado em execução é:
Xiao Ming pediu ajuda a Xiaohong para calcular: 26549 + 16487 = 43036
O processo de execução é: Xiao Ming chama o método ADD de Xiao Hong （new SuperCalculator()） através de seu próprio método callhelp e passa sua própria referência (este) como um parâmetro ao chamar. Depois que Xiao Hong usa a calculadora para obter o resultado, ele chama de volta o método de preenchimento de Xiao Ming e preenche o resultado no espaço no quadro -negro.
Luzes e luzes! Nesse ponto, a função de retorno de chamada estreou oficialmente. O método Fillblank de Xiao Ming é o que frequentemente temos a função de retorno de chamada.
Dessa forma, pode -se ver claramente que Xiao Ming não precisa mais esperar até que a adição seja concluída e o resultado seja preenchido no quadro -negro antes que ele possa se divertir com seus amigos. O trabalho de preenchimento em branco é realizado por Xiaohong, a super calculadora. As vantagens dos retornos de chamada começaram a ser refletidas.
Capítulo 4. A sogra na porta
Há uma velha senhora com cabelos grisalhos na entrada do jardim de infância. Ela montou uma barraca de rua lá vendendo junk food que quase expirou todos os dias, independentemente do vento e da chuva. Por ser velho, minha mente está um pouco confusa e muitas vezes não consigo descobrir quanto dinheiro ganhei. Um dia, ela acidentalmente ouviu Xiao Ming se gabou de como lutou com inteligência e coragem com o professor do jardim de infância com a ajuda de Xiaohong. Então, minha sogra decidiu encontrar a pequena super calculadora do cartão vermelho como seu pequeno ajudante e fornecer um pacote de tiras picantes Weilong como recompensa. Xiaohong não pôde resistir à tentação e concordou.
Olhando para o código no capítulo anterior, descobrimos que os parâmetros exigidos pelo método ADD da Little Red Card Super Calculator são duas variáveis inteiras e um objeto estudantil , mas a velha senhora não é uma estudante, mas uma pequena fornecedora, então ela deve fazer modificações aqui. Nesse caso, é natural que pensemos em herança e polimorfismo. Se pedirmos ao aluno Xiao Ming e ao fornecedor da velha senhora para herdar de uma classe de pais, precisamos passar apenas uma referência à classe pai para a pequena calculadora do Little Red Card.
No entanto, no uso real, considerando a herança única de Java e não querendo expor muito por si mesma a outros, usamos o método de herdar da interface para cooperar com classes internas.
Em outras palavras, Xiaohong espera continuar fornecendo serviços de cálculo para as crianças da classe no futuro e, ao mesmo tempo, prestar serviços de contabilidade à velha dama e até expandir os negócios de outras pessoas no futuro. Então, ela concordou com todos os clientes um método para processamento unificado, ou seja, os operando que ela precisa e como fazê -lo após concluir o cálculo. Xiaohong transformou este método unificado em uma interface e fornecido a todos, o código é o seguinte:
interface pública Dojob {public void FillBlank (int a, int b, int resultado); }Como a inspiração veio de ajudar Xiao Ming a preencher os espaços em branco, Xiaohong manteve sua intenção original e tratou todos os seus negócios como Fillblank .
Ao mesmo tempo, Xiaohong modificou sua calculadora para que possa lidar com pessoas diferentes que implementam a interface do dojob ao mesmo tempo. O código é o seguinte:
classe pública supercalculator {public void add (int a, int b, dojob cliente) {int resultado = a + b; cliente.fillblank (a, b, resultado); }} Depois que Xiao Ming e a velha senhora receberam essa interface, desde que implementassem essa interface, é equivalente a contar a Xiaohong o caminho para lidar com os resultados em um modelo unificado e usar classes internas, como mencionado anteriormente. O código é o seguinte:
Xiao Ming's:
public class Student {private string name = null; Public Student (Nome da String) {// TODO Construtor Auto-Gerado Stub this.name = Name; } public void setName (nome da string) {this.name = name; } classe pública Dohomework implementa dojob {@Override public void FillBlank (int a, int b, int resultado) {// TODO Método Geral Goldado Sistema System.out.println (Nome + "Procurando ajuda do Xiaohong Cálculo:" + A + " +" + B + "=" + resultado); }} public void callP (int a, int b) {new supercalculator (). add (a, b, novo dohomework ()); }} Velhinha:
Public class Seller {private String Name = null; vendedor público (nome da string) {// TODO Construtor Auto-Gerado Stub this.name = name; } public void setName (nome da string) {this.name = name; } public class doHomeWork implements doJob { @Override public void fillBlank(int a, int b, int result) { // TODO Auto-generated method stub System.out.println(name + "Seeking help Xiaohong to settle accounts:" + a + " + " + " + b + " = " + result + "Meta"); } } public void callHelp (int a, int b) { novo supercalculator (). add (a, b, novo dohomework ()); O procedimento de teste é o seguinte:
classe pública teste {public static void main (string [] args) {int a = 56; int b = 31; int c = 26497; int d = 11256; Aluno s1 = novo aluno ("xiao ming"); Vendedor s2 = novo vendedor ("avó"); s1.callhelp (a, b); S2.Callhelp (C, D); }} Os resultados da operação são os seguintes:
Xiao Ming pediu ajuda a Xiaohong para calcular: 56 + 31 = 87
A velha senhora pede ajuda de Xiaohong para liquidar contas: 26497 + 11256 = 37753 Yuan
Resumir
Pode -se ver claramente que Xiaohong já tratou esse assunto como uma carreira, e você saberá, olhando para o nome que ela deu à interface dojob .
Algumas pessoas podem perguntar: por que uma velha senhora pode ganhar tanto dinheiro montando uma barraca? Existe algum problema com o seu foco? ! O que estamos falando aqui é o mecanismo de retorno de chamada! !
Tudo o que sei é que os negócios de Xiaohong continuaram a se expandir mais tarde e, antes de se formar no jardim de infância, ela finalmente comprou sua primeira casa em sua vida com o dinheiro que ganhou.
O exposto acima é uma explicação interessante e detalhada do mecanismo de retorno de chamada (retorno de chamada) em Java. Espero que seja útil para todos aprenderem Java. Obrigado pelo seu apoio ao wulin.com.