Es gibt immer diese bestimmten Schnittstellen zwischen Modulen. Aus Sicht der Anrufmethoden können sie in drei Kategorien unterteilt werden: synchrone Anrufe, Rückrufe und asynchrone Anrufe. Das Folgende konzentriert sich darauf, den Rückrufmechanismus im Detail zu erklären.
1. Übersicht
Der Rückrufmechanismus in Java ist ein relativ häufiger Mechanismus, kann jedoch in Ihrem Programm weniger verwendet werden, und in einigen großen Frameworks sind überall überall zu sehen. In diesem Artikel werden einige spezifische Beispiele verwendet, um sich langsam dem Rückrufmechanismus von Java näher zu bringen.
2. Rückruf
Der sogenannte Rückruf: Es bedeutet, eine Methode C in der Klasse A in Klasse B aufzurufen und dann die Methode D in Klasse A in Klasse B in Klasse B aufzurufen. Diese Methode D wird als Rückrufmethode bezeichnet. Wenn es tatsächlich verwendet wird, gibt es unterschiedliche Rückrufformulare, wie z. B. die folgenden.
2.1 Synchrone Rückrufe
Hier nehme ich eine solche Situation an.
Der Direktor von Company A teilte seinem Untergebenen (Projektmanager C) mit, er wolle eine Umfrage durchführen, aber C müsse es nicht selbst machen. Manager C kann gebeten werden, seinen Programmierer D zu vervollständigen. Manager C fand den Programmierer D und sagte ihm, dass jetzt eine Forschungsaufgabe abgeschlossen sein würde. Und teilen Sie dem Manager C die Ergebnisse der Umfrage mit. Wenn es ein Problem gibt, müssen Sie weiterhin fortfahren. Denn hier ist C, das D bittet, etwas zu tun, Danach muss D das Ergebnis immer noch mit C kommunizieren. Dies ist das Rückrufmodell. Das Folgende ist das allgemeine Rückrufklassendiagramm:
Zuerst müssen wir eine Callback -Schnittstelle CallbackInterface haben
CallbackInterface.java
public interface callbackinterface {public boolean check (int Ergebnis);} Im Hintergrund möchte Programmierer D die Ergebnisse mit dem Projektmanager C kommunizieren, sodass der Projektmanager die oben genannte Callback -Schnittstelle implementieren muss:
Manager.java
public class Manager implementiert CallbackInterface {private Programmierer Programmierer = NULL; Public Manager (Programmierer _programmer) {this.programmer = _programmer; } / *** verwendet für die vom Boss ausgestellte Delegation* / public void montrust () {arrangement (); } // Untergebene planen, um Arbeiten privat void arrang () {System.out.println ("Manager arrangieren Arbeiten für den Programmierer"); Programmierer.Study (Manager.This); System.out.println ("Der Arbeitsplan für den Programmierer wurde abgeschlossen, und der Manager hat andere Dinge getan."); } @Override public boolean check (int result) {if (result == 5) {return true; } return false; }} Für den Programmierer D muss er ein Angebot von Manager C abhalten, um mit ihm zu kommunizieren. Hier ist jedoch die Aufgabe, die Director B Manager C gebeten hat, zu arrangieren. Mit anderen Worten, andere Manager können auch hier gefragt werden, wie z. B. Manager B1, B2 usw. Da die Manager die Callback -Schnittstelle implementiert haben, können Sie Programmierer D direkt diese Schnittstelle hier halten lassen. wie folgt:
Programmierer.java
public class Programmer {public void Study (CallbackInterface -Rückruf) {int result = 0; do {result ++; System.out.println ("Th" + Ergebnis + "Ergebnis der Studie"); } while (! callback.check (Ergebnis)); System.out.println ("Umfragetask endet"); }} Für den Direktor ist es noch einfacher und klarer, da dies einem Kundentest entspricht:
Boss.java
public class boss {public static void main (String [] args) {Manager Manager = New Manager (neuer Programmierer ()); Manager.Entrust (); }} Auslaufergebnisse:
Manager arrangiert die Arbeit für den Programmierer. Ergebnisse der 1. Studie. Ergebnisse der 2. Studie. Ergebnisse der 3. Studie. Ergebnisse der 4. Studie. Ergebnisse der 5. Studie. Die 5. Studie. Die Planungsarbeiten für den Programmierer wurden abgeschlossen. Manager hat andere Dinge getan.
2.2 Asynchrone Rückrufe
Wie im obigen Beispiel, kann Ihr Projektmanager nicht immer auf die Ergebnisse Ihrer Forschung warten. Aber nachdem Sie diese Aufgabe Ihnen übergeben haben, wird er sie ignorieren. Er wird sein eigenes Ding machen, du wirst dein eigenes Ding machen. Daher muss die Rückruffunktion hier asynchron verarbeitet werden.
Hier müssen wir den Code der Programmiererklasse ändern und wie folgt ändern:
Programmierer.java
public class Programmierer {public programmer () {} public void Study (CallbackInterface Callback) {New StudyThread (Callback) .Start (); } // --------------------------- Programmierer 正在做的工作 --------------------------- StudyThread erweitert Thread {CallbackInterface callback = null; public StudyThread (CallbackInterface _callback) {callback = _callback; } @Override public void run () {int result = 0; do {result ++; System.out.println ("Th" + Ergebnis + "Ergebnis der Studie"); } while (! callback.check (Ergebnis)); System.out.println ("Umfragetask endet"); }}}Auslaufergebnisse:
Manager plant Arbeit für Programmierer Die Planungsarbeit für Programmierer wurde abgeschlossen und Manager macht andere Dinge.
Ergebnisse der 1. Studienergebnisse der 2. Studienergebnisse der 3. Studienergebnisse der 4. Studienergebnisse der 5. Studie, die die Forschungsaufgabe endete
2.3 Schließungen und Rückrufe
Eine Schließung ist ein Callable -Objekt, das einige Informationen aus dem Bereich, in dem er erstellt wurde, aufgezeichnet wird.
2.3.1 Normaler Anruf
Zunächst können wir sehen, wie der Anruf unter normalen Umständen getätigt wird.
Inkrementierbar.java
Schnittstelle inkrementierbar {void Increment ();}Dies ist eine gewöhnliche Schnittstelle (es handelt sich nur um eine normale Schnittstelle in gewöhnlichen Aufrufen, und es handelt sich um eine Rückrufschnittstelle in einem Rückruf, was leicht zu verstehen ist).
Callee1.java
Klasse callee1 implementiert inkrementierbar {private int i = 0; @Override public void Increment () {i ++; System.out.println (i); }}Callbacks.java
public class callbacks {public static void main (String [] args) {callee1 callee1 = new Callee1 (); Callee1.increment (); }}Callbacks ist eine Test -Client -Klasse, es gibt nichts zu sagen. Schauen Sie sich einfach den obigen Code an.
2.3.2 Erstversuch von Rückrufen
Über die oben genannten gewöhnlichen Anrufe gibt es nichts zu sagen, denn für einen normalen Java -Programmierer sollte dies etwas sein, das ohne nachzudenken getan werden kann.
Wenn Sie nun einen Rückruf bilden möchten, ist es unmöglich, nur einen Callee (das Callback -Objekt Callee1) in Bezug auf die Struktur oder Logik des Programms zu haben, und Sie benötigen auch ein Anruferobjekt. Der Anrufer kann es so schreiben:
Caller.java
Klassenanrufer {private inkrementierbare CallbackReferation; public Caller (inkrementierbar _callbackReferation) {callbackReference = _callbackReference; } void go () {callbackReference.increment (); }} Hier hält Caller eine CallbackReferation für eine Callback -Oberfläche, genau wie der oben erwähnte Programmierer die Referenz eines Projektmanagers benötigt, damit Sie über diese Referenz mit dem Projektmanager kommunizieren können. Die CallbackReferation hier spielt auch diese Rolle.
Schauen wir uns nun das Schreiben der Testklasse an:
Callbacks.java
public class callbacks {public static void main (String [] args) {callee1 callee1 = new Callee1 (); Caller Caller1 = neuer Anrufer (Callee1); caller1.go (); }}Für den bisherigen Programmcode können wir den darüber vergleichenden Code, über den der Projektmanager Programmierer verabreicht, vollständig vergleichen, um technische Probleme zu untersuchen. Es hat den gleichen Effekt.
2.3.3 Abschluss Rückruf
Im Vergleich zu normalen Rückernständen liegt der Kern der Abschlussrückrufe natürlich in Verschlüssen, dh die Kontrolle über den Umfang.
Nehmen wir nun an, dass ein Benutzer (anderer Programmierer) eine MyIncrement -Klasse anpasst und eine Inkrementmethode enthält. wie folgt:
Klasse myIncrement {public void Increment () {System.out.println ("mycrement.increment"); } static void f (myIncrement Increment) {increment.increment (); }}Es gibt eine andere Klasse Callee2, die aus der obigen Klasse geerbt wurde:
Klasse Callee2 erweitert myIncrement {private int i = 0; public void Increment () {Super.increment (); i ++; System.out.println (i); }}Es ist offensichtlich, dass, wenn Sie hier die Inkrement () -Methode aufrufen möchten, ein allgemeiner Funktionsaufruf wird. Hier müssen wir also die obige Callee2 -Klasse ändern. Ziel der Modifikation ist es, die Callee2 -Klasse mit der Increment () -Methode der MyIncrement -Klasse und der Increment () -Methode des inkrementierbaren Verfahrens kompatibel zu machen. Nach der Änderung:
Klasse Callee2 erweitert myIncrement {private int i = 0; public void Increment () {Super.increment (); i ++; System.out.println (i); } private class closure implementiert inkrementierbar {@Override public void Increment () {callee2.this.increment (); }} Inkrementierbar getCallbackReference () {return New Closure (); }} Beachten Sie, dass die Schließklasse hier eine private Klasse ist, die ein Element eines Verschlusses ist. Da die Schließklasse privat ist, muss es eine offene Schnittstelle für Vorgänge für Schließobjekte geben. Dies ist die obige GetCallbackReference () -Methode. Die Anruferklasse hat sich nicht geändert.
Zum Testen von Clients schauen Sie sich einfach den Code an:
public class Callbacks {public static void main (String [] args) {callee2 callee2 = new Callee2 (); Caller Caller2 = neuer Anrufer (Callee2.getCallbackReference ()); caller2.go (); }}Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.