Eine wunderbare Erklärung des Callback-Mechanismus in Java (CallBack)

Vorwort

Ich habe kürzlich Java gelernt und bin mit dem Rückrufmechanismus (CallBack) in Berührung gekommen. Als ich es zum ersten Mal traf, empfand ich es als ziemlich verwirrend, und die relevanten Erklärungen, die ich im Internet fand, wurden entweder in einem Satz erklärt oder sie waren relativ einfach und schienen eine Definition für CallBack zu liefern. Nachdem ich die Rückrufe verstanden hatte, habe ich natürlich verschiedene Erklärungen im Internet gelesen und es gab wirklich kein Problem. Allerdings fehlt mir als Anfänger eine Schritt-für-Schritt-Anleitung.

Rückruf ist ein Zwei-Wege-Anrufmodus. Das heißt, der Angerufene ruft auch den anderen Teilnehmer an, wenn er angerufen wird. „Wenn Sie mich anrufen, rufe ich zurück.“

Nicht verstehen? Egal, schauen wir uns diese wohl klassischere Art der Verwendung von Rückrufen an:

Klasse A implementiert die Schnittstelle InA - Hintergrund 1

Klasse A enthält a Klasse B Referenz b – Hintergrund 2

Klasse B hat eine Methode test(InA a) mit einem Parameter von InA – Hintergrund 3

As Objekt a ruft Bs The auf Methode besteht in sich selbst, test(a) – dieser Schritt entspricht „Du rufst mich an“

und dann kann b die Methode von InA in der Testmethode aufrufen – dieser Schritt entspricht „Ich rufe dich zurück“

Bevor Sie beginnen, stellen Sie sich eine Szene vor: Kindergartenkinder haben gerade innerhalb von 10 Minuten Addition gelernt.

Im Folgenden werde ich mein persönliches Verständnis des Rückrufmechanismus beschreiben, von flacher nach tiefer. Wenn etwas nicht stimmt, können Sie mich gerne aufklären!

Kapitel 1. Der Ursprung der Geschichte

Die Kindergärtnerin schrieb eine Gleichung „1 + 1 =“ an die Tafel und Xiao Ming füllte die Lücken aus.

Da er die Addition innerhalb von 10 gelernt hat, kann Xiao Ming dieses Problem vollständig selbst berechnen. Der Code zur Simulation des Prozesses lautet wie folgt:

public class Student
 {
  private String name = null;
 
  public Student(String name)
  {
   // TODO Auto-generated constructor stub
   this.name = name;
  }
 
  public void setName(String name)
  {
   this.name = name;
  }
 
  private int calcADD(int a, int b)
  {
   return a + b;
  }
 
  public void fillBlank(int a, int b)
  {
   int result = calcADD(a, b);
   System.out.println(name + "心算:" + a + " + " + b + " = " + result);
  }
 }

Xiao Ming füllt die Lücken aus (fillBalnk) Zu diesem Zeitpunkt habe ich etwas Kopfrechnen (clacADD) durchgeführt und festgestellt, dass das Ergebnis 2 war, und das Ergebnis in das leere Feld geschrieben. Der Testcode lautet wie folgt:

public class Test
 {
  public static void main(String[] args)
  {
  int a = 1;
   int b = 1;
   Student s = new Student("小明");
   s.fillBlank(a, b);
  }
 }

Die Laufergebnisse lauten wie folgt:

Xiao Mings Kopfrechnen: 1 + 1 = 2

Dieser Prozess wird vollständig allein vom Instanzobjekt der Student-Klasse abgeschlossen und beinhaltet keinen Rückrufmechanismus.

Kapitel 2. Die Kindergärtnerin auf der Suche nach Ärger

Während der Pause hatte die Kindergärtnerin eine plötzliche Idee und schrieb „168 + 291 =" an die Tafel, damit Xiao Ming sie ausfüllen konnte, und dann zurück ins Büro.

Blumenmassage! Warum haben alle Lehrer Probleme mit Xiao Ming? Es ist offensichtlich übertrieben, okay! Zu diesem Zeitpunkt war es offensichtlich, dass Xiao Ming sich nicht mehr auf Kopfrechnen wie oben verlassen konnte. Als er verwirrt war, reichte Xiao Hong, ein Klassenkamerad in der Klasse, einen Taschenrechner, der nur Addition (Profiteur) berechnen konnte! ! ! ! Xiao Ming wusste zufällig, wie man einen Taschenrechner benutzt, also benutzte er den Taschenrechner, um die Ergebnisse zu berechnen und die Lücken auszufüllen.

Der Code des Rechners lautet:

public class Calculator
 {
  public int add(int a, int b)
  {
   return a + b;
  }
 }

Ändern Sie die Student-Klasse und fügen Sie eine Methode zur Verwendung des Rechners hinzu:

public class Student
 {
  private String name = null;
 
  public Student(String name)
  {
   // TODO Auto-generated constructor stub
   this.name = name;
  }
 
  public void setName(String name)
  {
   this.name = name;
  }
 
  @SuppressWarnings("unused")
  private 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 result = useCalculator(a, b);
   System.out.println(name + "使用计算器:" + a + " + " + b + " = " + result);
  }
 }

Der Testcode lautet wie folgt:

public class Test
 {
  public static void main(String[] args)
  {
   int a = 168;
   int b = 291;
   Student s = new Student("小明");
   s.fillBlank(a, b);
  }
 }

Xiao Ming verwendet einen Taschenrechner: 168 + 291 = 459

Der Rückrufmechanismus ist noch nicht an diesem Prozess beteiligt, aber einige der Arbeiten von Xiao Ming wurden übertragen und werden vom Rechner unterstützt.

3. Die Kindergärtnerin kam zurück

und stellte fest, dass Xiao Ming die Addition von drei Ziffern abgeschlossen hatte. Die Lehrerin hielt Xiao Ming für sehr klug und ein formbares Talent. Also schrieb er „26549 + 16487 =“ an die Tafel und bat Xiao Ming, die Lücken auszufüllen, bevor er zum Unterricht ging, und kehrte dann ins Büro zurück.

Xiao Ming sah den Freunden zu, die sich außerhalb des Klassenzimmers amüsierten, und konnte nicht anders, als traurig zu sein. Wenn wir nicht zum Spielen rausgehen, wird diese Pause ruiniert! ! ! ! Als Xiao Ming den Taschenrechner, den Xiao Hong ihm noch einmal überreichte, betrachtete, fasste er einen Plan: Lass Xiao Hong es für sie tun.

Xiao Ming sagte zu Xiao Hong, dass das Thema „26549 + 16487 =“ sei, wies dann auf die konkrete Stelle hin, an der das Ergebnis eingetragen werden sollte, und ging dann fröhlich zum Spielen hinaus.

Anstatt Xiaohong separat zu implementieren, betrachten wir hier diesen Rechner, der nur Additionen und Xiaohong als Ganzes durchführen kann, einen Superrechner, der Ergebnisse berechnen und Lücken füllen kann. Die Parameter, die an diesen Superrechner übergeben werden müssen, sind zwei Addends und die auszufüllende Position, und diese Inhalte müssen von Xiao Ming im Voraus mitgeteilt werden. Das bedeutet, dass Xiao Ming Xiao Hong einen Teil seiner Methode offenbaren möchte. Der einfachste Weg besteht darin, Xiaohong das Zitat und die beiden Ergänzungen zusammen mitzuteilen.

Daher sollte die Add-Methode des Superrechners zwei Operanden und einen Verweis auf Xiao Ming selbst enthalten. Der Code lautet wie folgt:

Xiao Ming braucht weder Kopfrechnen noch einen Taschenrechner, er braucht also nur noch eine Möglichkeit, Xiao Hong um Hilfe zu bitten. Der Code lautet wie folgt:

public class SuperCalculator
 {
  public void add(int a, int b, Student xiaoming)
  {
   int result = a + b;
   xiaoming.fillBlank(a, b, result);
  }
 }

Der Testcode lautet wie folgt:

public class Student
 {
  private String name = null;
 
  public Student(String name)
  {
   // TODO Auto-generated constructor stub
   this.name = name;
  }
 
  public void setName(String name)
  {
   this.name = name;
  }
 
  public void callHelp (int a, int b)
  {
   new SuperCalculator().add(a, b, this);
  }
 
  public void fillBlank(int a, int b, int result)
  {
   System.out.println(name + "求助小红计算:" + a + " + " + b + " = " + result);
  }
 }

Das laufende Ergebnis lautet:

public class Test
 {
  public static void main(String[] args)
  {
   int a = 26549;
   int b = 16487;
   Student s = new Student("小明");
   s.callHelp(a, b);
  }
 }

Xiao Ming fragt Xiao Hong für Hilfe bei der Berechnung: 26549 + 16487 = 43036

Der Ausführungsprozess ist: Xiao Ming ruft die Add-Methode von Xiao Hong (neuer SuperCalculator()) über seine eigene callHelp-Methode auf und behandelt seine eigene Referenz (dies) as Die Parameter werden zusammen übergeben. Nachdem Xiaohong den Taschenrechner verwendet hat, um das Ergebnis zu erhalten, ruft sie Xiaomings fillBlank-Methode zurück und füllt das Ergebnis in den leeren Raum auf der Tafel.

Licht, Licht, Licht! An diesem Punkt erscheint offiziell die Callback-Funktion. Die fillBlank-Methode von Xiao Ming wird oft als Callback-Funktion bezeichnet.

通过这种方式，可以很明显的看出，对于完成老师的填空题这个任务上，小明已经不需要等待到加法做完且结果填写在黑板上才能去跟小伙伴们撒欢了，填空这个工作由超级计算器小红来做了。回调的优势已经开始体现了。

第4章. 门口的婆婆

幼稚园的门口有一个头发花白的老婆婆，每天风雨无阻在那里摆着地摊卖一些快过期的垃圾食品。由于年纪大了，脑子有些糊涂，经常算不清楚自己挣了多少钱。有一天，她无意间听到了小明跟小伙伴们吹嘘自己如何在小红的帮助下与幼师斗智斗勇。于是，婆婆决定找到小红牌超级计算器来做自己的小帮手，并提供一包卫龙辣条作为报酬。小红经不住诱惑，答应了。

回看一下上一章的代码，我们发现小红牌超级计算器的add方法需要的参数是两个整型变量和一个Student对象，但是老婆婆她不是学生，是个小商贩啊，这里肯定要做修改。这种情况下，我们很自然的会想到继承和多态。如果让小明这个学生和老婆婆这个小商贩从一个父类进行继承，那么我们只需要给小红牌超级计算器传入一个父类的引用就可以啦。

不过，实际使用中，考虑到java的单继承，以及不希望把自身太多东西暴漏给别人，这里使用从接口继承的方式配合内部类来做。

换句话说，小红希望以后继续向班里的小朋友们提供计算服务，同时还能向老婆婆提供算账服务，甚至以后能够拓展其他人的业务，于是她向所有的顾客约定了一个办法，用于统一的处理，也就是自己需要的操作数和做完计算之后应该怎么做。这个统一的方法，小红做成了一个接口，提供给了大家，代码如下：

public interface doJob
 {
  public void fillBlank(int a, int b, int result);
 }

   

因为灵感来自帮小明填空，因此小红保留了初心，把所有业务都当做填空（fillBlank）来做。

同时，小红修改了自己的计算器，使其可以同时处理不同的实现了doJob接口的人，代码如下：

public class SuperCalculator
 {
  public void add(int a, int b, doJob customer)
  {
   int result = a + b;
   customer.fillBlank(a, b, result);
  }
 }

   

小明和老婆婆拿到这个接口之后，只要实现了这个接口，就相当于按照统一的模式告诉小红得到结果之后的处理办法，按照之前说的使用内部类来做，代码如下：
小明的：

public class Student
 {
  private String name = null;
 
  public Student(String name)
  {
   // TODO Auto-generated constructor stub
   this.name = name;
  }
 
  public void setName(String name)
  {
   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 + "求助小红计算:" + a + " + " + b + " = " + result);
   }
 
  }
 
  public void callHelp (int a, int b)
  {
   new SuperCalculator().add(a, b, new doHomeWork());
  }
 }

   

老婆婆的：

public class Seller
{
 private String name = null;
 
 public Seller(String name)
 {
  // TODO Auto-generated constructor stub
  this.name = name;
 }
 
 public void setName(String name)
 {
  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 + "求助小红算账:" + a + " + " + b + " = " + result + "元");
  }
 
 }
 
 public void callHelp (int a, int b)
 {
  new SuperCalculator().add(a, b, new doHomeWork());
 }
}

   

测试程序如下：

public class Test
{
 public static void main(String[] args)
 {
  int a = 56;
  int b = 31;
  int c = 26497;
  int d = 11256;
  Student s1 = new Student("小明");
  Seller s2 = new Seller("老婆婆");
 
  s1.callHelp(a, b);
  s2.callHelp(c, d);
 }
}

   

运行结果如下：

小明求助小红计算:56 + 31 = 87

老婆婆求助小红算账:26497 + 11256 = 37753元

总结

可以很明显的看到，小红已经把这件事情当做一个事业来做了，看她给接口命的名字doJob就知道了。

有人也许会问，为什么老婆婆摆摊能挣那么多钱？ 你的关注点有问题好吗！！这里聊的是回调机制啊！！

我只知道，后来小红的业务不断扩大，终于在幼稚园毕业之前，用挣到的钱买了人生的第一套房子。

以上就是本文对于Java中的回调机制(CallBack) 的有趣详解，希望给大家学习java有所帮助。也谢谢大家对PHP中文网的支持。

更多妙解Java中的回调机制(CallBack)相关文章请关注PHP中文网！