Il y a toujours ces certaines interfaces entre les modules. Du point de vue des méthodes d'appel, ils peuvent être divisés en trois catégories: appels synchrones, rappels et appels asynchrones. Ce qui suit se concentre sur l'explication du mécanisme de rappel en détail.
1. Présentation
Le mécanisme de rappel en Java est un mécanisme relativement courant, mais il peut être moins utilisé dans votre programme, et les mécanismes de rappel peuvent être vus partout dans certains grands cadres. Cet article utilise des exemples spécifiques pour se rapprocher lentement du mécanisme de rappel de Java.
2. Rappel
Le soi-disant rappel: cela signifie appeler une méthode C dans la classe A dans la classe B, puis appeler la méthode D dans la classe A dans la classe B dans la classe B. Cette méthode D est appelée méthode de rappel. Lorsque vous l'utilisez réellement, il y aura différents formulaires de rappel, comme les suivants.
2.1 rappels synchrones
Je suppose ici une telle situation.
Le directeur de la société A B a déclaré à son subordonné (chef de projet C) qu'il voulait faire une enquête, mais C n'avait pas besoin de le faire lui-même. Le gestionnaire C peut être invité à organiser son programmeur D pour le terminer. Le directeur C a trouvé le programmeur D et lui a dit qu'une tâche de recherche serait terminée maintenant. Et dire au gestionnaire C les résultats de l'enquête. S'il y a un problème, vous devez toujours continuer. Parce que voici C demande à D de faire quelque chose, D doit toujours communiquer le résultat avec C après cela. Ceci est le modèle de rappel. Ce qui suit est le diagramme général de classe de rappel:
Nous devons d'abord avoir une interface de rappel CallbackInterface
Callbackinterface.java
Interface publique CallBackInterface {public booléen chèque (INT Result);} En arrière-plan, Programmer D veut communiquer les résultats avec Project Manager C, de sorte que le chef de projet doit implémenter l'interface de rappel ci-dessus:
Manager.java
Gestionnaire de classe publique implémente callbackInterface {private programmer programmer = null; Public Manager (programmeur _Programmer) {this.Programmer = _Programmer; } / ** * Utilisé pour la délégation émise par le boss * / public void fidust () {arrangement (); } // Planifiez les subordonnés pour étudier le travail privé void arrange () {System.out.println ("Manager organise le travail pour le programmeur"); programmer.Study (Manager.Chis); System.out.println ("Le calendrier de travail pour le programmeur a été terminé, et le gestionnaire est allé faire autre chose."); } @Override public boolean check (int result) {if (result == 5) {return true; } return false; }} Pour le programmeur D, il doit tenir un devis du manager C afin de communiquer avec lui. Cependant, voici la tâche que le directeur B a demandé au directeur C d'organiser. En d'autres termes, d'autres gestionnaires peuvent également être interrogés ici, tels que les gestionnaires B1, B2, etc. Parce que les gestionnaires ont implémenté l'interface de rappel, vous pouvez directement laisser le programmeur D maintenir cette interface ici. comme suit:
Programmeur.java
PUBLIC CLASS PROGRAMMER {public void Study (callbackInterface Callback) {int result = 0; do {result ++; System.out.println ("Th" + Result + "Résultat de l'étude"); } while (! callback.check (résultat)); System.out.println ("Tâche d'enquête se termine"); }} C'est encore plus simple et plus clair pour le directeur, car cela équivaut à un test client:
Boss.java
classe publique Boss {public static void main (String [] args) {manager manager = new manager (new programmeur ()); manager.entrust (); }} Résultats en cours:
Le gestionnaire organise des travaux pour le programmeur. Résultats de la 1ère étude. Résultats de la 2e étude. Résultats de la 3e étude. Résultats de la 4e étude. Résultats de la 5e étude. La 5e étude. Le travail de planification pour programmeur est terminé. Le manager a fait d'autres choses.
2.2 rappels asynchrones
Quant à l'exemple ci-dessus, votre chef de projet ne peut pas toujours attendre les résultats de vos recherches. Mais après vous avoir remis cette tâche, il l'ignorera. Il fera son propre truc, vous ferez votre propre truc. Par conséquent, la fonction de rappel doit être traitée de manière asynchrone ici.
Donc, ici, nous devons modifier le code de la classe du programmeur et le modifier comme suit:
Programmeur.java
public class Programmer {public Programmer () {} public void Study (callbackInterface Callback) {new StudyThread (callback) .start (); } // --------------------------- Programmer 正在做的工作 --------------------------- Class Studythread étend Thread {callbackInterface callback = null; Public StudyThread (callbackInterface _Callback) {callback = _Callback; } @Override public void run () {int result = 0; do {result ++; System.out.println ("Th" + Result + "Résultat de l'étude"); } while (! callback.check (résultat)); System.out.println ("Tâche d'enquête se termine"); }}}Résultats en cours:
Le gestionnaire est de planifier des travaux pour le programmeur Le travail de planification pour le programmeur a été terminé, et Manager fait d'autres choses.
Résultats des résultats de la 1ère étude des résultats de la 2e étude des résultats de la 3e étude des résultats de la 4e étude de la 5e étude La tâche de recherche a mis fin
2.3 fermetures et rappels
Une fermeture est un objet appelable qui enregistre certaines informations de la portée dans laquelle il a été créé.
2.3.1 Appel normal
Tout d'abord, nous pouvons voir comment l'appel est fait dans des circonstances normales.
Incrémentable.java
Interface incrémentable {void incrément ();}Il s'agit d'une interface ordinaire (c'est juste une interface normale dans les appels ordinaires, et c'est une interface de rappel dans un rappel, qui devrait être facile à comprendre).
Callee1.java
class Callee1 implémente incrémentable {private int i = 0; @Override public void incment () {i ++; System.out.println (i); }}Rappels.java
CAPPLESS DE CLASSE PUBLIQUES {public static void main (String [] args) {Callee1 Callee1 = new Callee1 (); Callee1.increment (); }}Callbacks est une classe client de test, il n'y a rien à dire, il suffit de regarder le code ci-dessus.
2.3.2 Rappel Initial Trial
Il n'y a rien à dire sur les appels ordinaires ci-dessus, car pour un programmeur Java normal, cela devrait être quelque chose qui peut être fait sans réfléchir.
Maintenant, si vous souhaitez former un rappel, il est impossible d'avoir une seule Callee (l'objet de rappel Callee1) en termes de structure ou de logique du programme, et vous avez également besoin d'un objet d'appelant. L'appelant peut l'écrire comme ceci:
Appelant.java
Classe CALLER {private incrémentable callbackReference; Public Caller (incrémentable _CallBackReference) {callbackReference = _CallBackReference; } void go () {callbackReference.increment (); }} Ici, l'appelant détient une interface de rappel pour une interface de rappel, tout comme le programmeur mentionné ci-dessus doit contenir la référence d'un chef de projet, afin que vous puissiez communiquer avec le chef de projet via cette référence. Le callbackReference ici joue également ce rôle.
Jetons maintenant un coup d'œil à l'écriture de la classe de test:
Rappels.java
CAPPLESS DE CLASSE PUBLIQUES {public static void main (String [] args) {Callee1 Callee1 = new Callee1 (); Appeler CAPLEUR1 = NOUVEAU CALLER (CALLEE1); appelant1.go (); }}Pour le code du programme jusqu'à présent, nous pouvons comparer complètement le code au-dessus duquel le chef de projet organise les programmeurs pour enquêter sur les problèmes techniques. Il a le même effet.
2.3.3 Rappel de fermeture
Par rapport aux rappels normaux, le cœur des rappels de fermeture se trouve naturellement dans les fermetures, c'est-à-dire le contrôle de la portée.
Supposons maintenant qu'un utilisateur (un autre programmeur) personnalise une classe MyIncrement et comprend une méthode d'incrément. comme suit:
class MyIncrement {public void incment () {System.out.println ("MyCment.increment"); } static void f (MyIncrement incrément) {incment.increment (); }}Il y a une autre classe Callee2 héritée de la classe ci-dessus:
Class Callee2 étend MyIncrement {private int i = 0; public void incment () {super.increment (); i ++; System.out.println (i); }}Il est évident que si vous souhaitez appeler la méthode incrément () ici, cela devient un appel de fonction général. Nous devons donc ici modifier la classe CALLEE2 ci-dessus. L'objectif de la modification est de rendre la classe CALLEE2 compatible avec la méthode incrément () de la classe MyIncrement et la méthode incrément () de l'incrémentable. Après modification:
Class Callee2 étend MyIncrement {private int i = 0; public void incment () {super.increment (); i ++; System.out.println (i); } la fermeture de classe privée implémente incrémentable {@Override public void incment () {Callee2.This.increment (); }} GetCallBackReference incrémentable () {return new Close (); }} Notez que la classe de fermeture ici est une classe privée, qui est un élément de fermeture. Étant donné que la classe de fermeture est privée, il doit y avoir une interface ouverte pour les opérations sur les objets de fermeture. Il s'agit de la méthode getCallBackReference () ci-dessus. La classe des appels n'a pas changé.
Pour tester les clients, regardez le code:
Callbacks de classe publique {public static void main (String [] args) {callee2 callee2 = new Callee2 (); Appelant appelant2 = nouveau appelant (callee2.getCallBackReference ()); caller2.go (); }}Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.