Lassen Sie uns noch einmal über die Java-Callback-Funktion sprechen

Ich bin wieder auf eine Rückruffunktion gestoßen und dieses Mal habe ich vor, sie aufzuschreiben und zu teilen.

Die sogenannte Rückruffunktion oder Rückrufmethode in der objektorientierten Sprache ist vereinfacht gesagt eine Funktion, die zu einem bestimmten Zeitpunkt (Ereignis tritt ein) zurückgerufen wird.

Um genauer zu sein: Es handelt sich um eine Funktion A als Parameter, die an eine andere Funktion B übergeben und dann zu einem bestimmten Zeitpunkt von B aufgerufen wird.

Da eine Funktion eine andere Funktion aufruft, kann sie im Funktionskörper aufgerufen werden. Ganz zu schweigen davon Es gibt einige Sprachen (z. B. Java), die Funktionen nicht als Parameter unterstützen.

Ja, Sie können tatsächlich eine andere Funktion im Funktionskörper aufrufen. Es scheint keinen Unterschied in der Funktion zu geben, aber hier liegt ein Problem vor, das heißt, die Funktion, die Sie aufrufen möchten, ist fest codiert bedeutet, dass Funktion B nur Funktion A aufrufen kann. Was wäre also, wenn es in einem anderen Szenario eine Funktion C gäbe, die sich von A unterscheidet und zu einem bestimmten Zeitpunkt in B aufgerufen werden muss?

Lassen Sie uns weiter über die Rückruffunktion sprechen. In c/c++ kann die Rückruffunktion von einer anderen Funktion aufgerufen werden, indem Sie einen Funktionszeiger als Parameter verwenden In Python und Javascript können Sie Funktionen direkt als Objektparameter implementieren, aber was ist mit Java? C#, ich mag Java nicht mehr. Ich hatte einmal vor, Java in Zukunft nicht mehr zu verwenden, aber die Realität ist nicht so ideal. Jetzt möchte ich Android machen, also kann ich Java immer noch nicht loslassen Ich bin auf das Problem dieser Rückruffunktion gestoßen, auf das ich persönlich auch in Java gestoßen bin: Die in diesem Blog vorkommenden Sprachen außer Java können Rückrufe einfach und verständlich implementieren Das ist bei Java der Fall, sonst würde ich diesen Blog nicht schreiben.

Okay, reden wir weiter über die Implementierung von Callback-Methoden in Java. Der Schwerpunkt dieses Blogs liegt auf Java. In Java werden Rückrufmethoden durch Ausleihen von Schnittstellen implementiert. Ich habe im Internet einen Satz gefunden:

„Weisen Sie die Referenz des von der Klasse erstellten Objekts zu, das eine bestimmte Schnittstelle implementiert, der von der Schnittstelle deklarierten Schnittstellenvariablen.“ , dann kann die Schnittstellenvariable die Methode der implementierten Schnittstelle aufrufen.“
Es ist sehr verwirrend, lassen Sie es uns kurz erklären:
Es gibt eine Schnittstelle und es gibt eine Methode in der Schnittstelle (diese Methode ist die Methode, die zurückgerufen werden soll):

interface CallBackInterface {
  void callBackMethod();
}

Wir wissen, dass das Schnittstellenobjekt nicht direkt verwendet werden kann, da keine der darin enthaltenen Methoden implementiert ist. Suchen Sie also eine Klasse, um diese Schnittstelle zu implementieren.
Fügen Sie nun eine Klasse hinzu, um diese Schnittstelle zu implementieren:

interface CallBackInterface {
  void callBackMethod();
}
 
class CallBackClass implements CallBackInterface{
 
  @Override
  public void callBackMethod() {
    System.out.println("hello");
  }
}

Okay, der letzte Schritt: Weisen Sie das Objekt der Klasse zu, die die Schnittstelle implementiert zu Deklarierte Schnittstellenvariablen (ich habe sie in eine Methode geschrieben und dann außerhalb eine Klassen-Shell hinzugefügt):

public class CallBackTest {
 
  interface CallBackInterface {
    void callBackMethod();
  }
 
  class CallBackClass implements CallBackInterface {
 
    @Override
    public void callBackMethod() {
      System.out.println("hello");
    }
  }
 
  public void showCallBack() {
    CallBackInterface itfs = new CallBackClass();
    itfs.callBackMethod();
  }
}

Jetzt können Sie den Test aufrufen. Habe es ausprobiert :

public class Test {
  public static void main(String[] args) {
    new CallBackTest().showCallBack();
  }
}

Wenn es keine Überraschungen gibt, wird „Hallo“ jedenfalls erfolgreich ausgegeben, es liegt auf meiner Seite.

Ich habe das Beispiel zu Ende gelesen, also Lassen Sie mich Ihnen sagen, was ich getan habe. Genauer gesagt, wir haben eine Methode, die in einer bestimmten Methode aufgerufen werden muss (diese Methode ist die Rückrufmethode, es ist am besten, nicht direkt zu schreiben). Sie möchten, dass die Callback-Methode direkt in der Callback-Methode ausgeführt wird, und da Methoden in Java nicht als Parameter übergeben werden können, müssen wir diese Callback-Methode in die Schnittstelle einfügen (warum nicht eine Klasse? Keine abstrakte Klasse? Sondern eine Schnittstelle?). Sie können selbst nach abstrakten Klassen und Schnittstellen suchen (Ähnlichkeiten und Unterschiede, dieses Problem selbst lösen). Wenn eine Schnittstelle vorhanden ist, muss diese von der Klasse implementiert werden. Solange dem Objekt der Schnittstelle ein Objekt der implementierenden Klasse zugewiesen ist, kann das Objekt dieser Schnittstelle diese Methode aufrufen. Um dies zu verstehen, ist Polymorphismus ein wichtiger Punkt. Das hier verwendete polymorphe Wissen besteht darin, dass das Objekt der Schnittstelle erfolgreich von einer Unterklasse zugewiesen werden kann und die überschriebenen Methoden der Unterklasse aufgerufen werden können (Klassen haben auch ähnliche Konzepte).

Noch ein Punkt: Jede Klasse hier, die die CallbackInterface-Schnittstelle implementiert, kann wie folgt nach new platziert werden (d. h. Zuweisung):

public class CallBackTest {
  interface CallBackInterface {
    void callBackMethod();
  }
 
  class CallBackClass implements CallBackInterface {
 
    @Override
    public void callBackMethod() {
      System.out.println("hello");
    }
  }
 
  class Controller {
    private CallBackInterface cbitf;
    // 这个boolean只是为了模拟有事件，没啥实用价值
    public boolean somethingHappend;
    // 这里确实可以直接把CallBackClass做参数，而且省掉接口的定义
    // 但是这样做的话，就像是回调函数直接写在了调用函数里一样
    // 不明白的话就好好理解下"约定"和"调用者不管回调函数是怎么实现的"吧
    public Controller(CallBackInterface itfs) {
      somethingHappend = true;
      this.cbitf = itfs;
    }
 
    public void doSomething() {
      if(somethingHappend) {
        cbitf.callBackMethod();
      }
    }
  }
 
  public void showCallBack() {
    CallBackClass cbc = new CallBackClass();
    Controller ctrlr = new Controller(cbc);
    ctrlr.doSomething();
    // 其实上面也可以这样写在一行里
    // new Controller(new CallBackClass()).doSomething();
  }
}

Abschließend möchte ich noch etwas sagen. Tatsächlich ist diese Art von Anwendung in Android häufig anzutreffen.

Das Obige ist mein persönliches Verständnis und die Verwendung von Rückruffunktionen. Ich hoffe, es gefällt Ihnen allen.

Weitere Artikel zu Java-Rückruffunktionen finden Sie auf der chinesischen PHP-Website!