Beispielanalyse der Java-Implementierung der Schnittstellen-Callback-Methode

Der Hauptinhalt dieses Artikels besteht darin, Ihnen die allgemeine Verwendung von Schnittstellenrückrufen in der Java-Programmierung anhand von tatsächlichem Code zu zeigen. Er hat einen bestimmten Referenzwert.

Schnittstellenrückruf bedeutet: Sie können eine bestimmte verwenden. Wenn die Referenz des von der Klasse einer Schnittstelle erstellten Objekts der von der Schnittstelle deklarierten Schnittstellenvariablen zugewiesen wird, kann die Schnittstellenvariable die von der Klasse implementierte Methode der Schnittstelle aufrufen. Wenn eine Schnittstellenvariable eine Methode in der von der Klasse implementierten Schnittstelle aufruft, benachrichtigt sie tatsächlich das entsprechende Objekt, die Schnittstellenmethode aufzurufen. Dieser Vorgang wird als Schnittstellenrückruf der Objektfunktion bezeichnet.

Allgemeine Verwendung von Java-Schnittstellenrückrufen: Die Implementierung von Schnittstellen ähnelt tatsächlich der Vererbung abstrakter Klassen, mit der Ausnahme, dass die Vererbung auf Klassenebene erfolgt, während Schnittstellen auf der Ebene von Methoden und konstanten Sammlungen ausgeführt werden. Schnittstellen sind flexibler als abstrakte Klassen. Abstrakt und einfacher. Das Implementieren einer Schnittstelle kann als Erben einer oder mehrerer spezifischer Methoden und einiger Konstanten betrachtet werden. Die spezifischen Regeln der Schnittstelle werden hier nicht beschrieben.

Warum Schnittstellen und abstrakte Klassen verwenden? Denn aus vielen Perspektiven entspricht dies objektorientierten Gestaltungsideen, etwa dem Öffnungs- und Schließprinzip.

Aus praktischer Entwicklungsperspektive unterstützt Java keine Mehrfachvererbung. Um dies auszugleichen, ist die Existenz von Schnittstellen äußerst wichtig. Im Gegensatz zur Vererbung kann eine Klasse mehrere Schnittstellen implementieren.

Eine Hauptfunktion der Schnittstelle besteht darin, Rückrufe zu implementieren. Der Unterschied besteht darin, dass asynchrone Rückrufe Multithreading-Technologie verwenden Für die Rückrufe müssen asynchrone Rückrufe verwendet werden.

Im Folgenden wird der asynchrone Rückruf als Beispiel verwendet. Im Folgenden wird das Schreiben in Java als Beispiel verwendet. Das Gleiche gilt für Android.

1. Allgemeine Verwendung

Erstellen Sie eine neue Eintragsklasse Main und eine neue Schnittstelle InterfaceExample

public class Main implements InterfaceExample{
  public static void main(String[] args) {
    System.out.println("------接口使用测试--------");
    InterfaceTest test = new InterfaceTest();
    //调用InterfaceTest的handleThings方法，并传递Main的实例
    test.handleThings(new Main());
    System.out.println("------异步回调测试--------");
  }
  @Override  //重写接口方法
  public void sendMessage(String string) {
    System.out.println("接口回调成功，利用 " + string + " 做一些事");
  }
}
 
//接口也可以写在一个独立的.java文件里
interface InterfaceExample {
  void sendMessage(String string);
}

Im Folgenden wird eine neue Klasse InterfaceTest erstellt

public class InterfaceTest {
  //注意这里Main实例向上转型，接口变量引用了Main实例
  public void handleThings(InterfaceExample example) {
    new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("-----做一些事------");
        try {
          Thread.sleep(3000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        //回调接口方法
        example.sendMessage("接口传的参数");
      }
    }).start();
  }
}

Die endgültige Laufausgabe:

------接口使用测试--------
------异步回调测试--------
-----做一些事------
接口回调成功，利用 接口传的参数 做一些事

Asynchrone Verarbeitung kann auch durchgeführt werden, wenn handleThings in Main aufgerufen wird.

2. Kombinieren Sie anonyme innere Klassen, um Schnittstellenrückrufe zu implementieren

Die zweite Methode muss nur die Hauptklasse basierend auf der ersten Methode ändern

public class Main {
  public static void main(String[] args) {
    System.out.println("------接口使用测试--------");
    InterfaceTest test = new InterfaceTest();
    //调用InterfaceTest的handleThings方法，并使用实现了InterfaceExample接口的匿名内部类
    //在该匿名内部类中重写接口方法
    test.handleThings(new InterfaceExample() {
      @Override  //重写接口方法
      public void sendMessage(String string) {
        System.out.println("接口回调成功，利用 " + string + " 做一些事");
      }
    });
    System.out.println("------异步回调测试--------");
  }
}
interface InterfaceExample {
  void sendMessage(String string);
}

Wie Sie sehen, kann die Verwendung anonymer innerer Klassen den Code vereinfachen und die Programmstruktur klarer machen. Daher ist diese Verwendung sehr häufig. Das Klickereignis der vom Android-System bereitgestellten Ansicht verwendet diese Form des Rückrufs.

Die Ausgabe ist die gleiche:

------接口使用测试--------
------异步回调测试--------
-----做一些事------
接口回调成功，利用 接口传的参数 做一些事。

Das obige ist der detaillierte Inhalt vonBeispielanalyse der Java-Implementierung der Schnittstellen-Callback-Methode. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!