Analyse der Verwendung von anonymen Innern Klassen und Callback-Funktionen in der Android-Programmierung

Dieses Beispiel beschreibt die Verwendung von anonymen Innere Klassen und Callback-Funktionen in der Android-Programmierung. Hier ist eine Zusammenfassung, die zur Referenz bereitgestellt wird:

Wir verwenden in der Android-Entwicklung oft anonyme Innere Klassen und die darin enthaltenen Callback-Funktionen, zum Beispiel, wenn wir einen Button mit einem Listener setzen, müssen wir das OnCLickListener-Interface implementieren und die Onclick ()-Methode überschreiben, das ist anonyme Innere Klasse und Callback-Funktion, also wie viel verstehen Sie von Java-anonyme Innere Klassen und Callback-Funktionen? Dieses Dokument gibt eine detaillierte Erklärung.

Zunächst sollte bekannt sein, dass Innere Klassen ein Hauptzusatzteil der JAVA-Sprache sind. Innere Klassen können fast überall in einer Klasse platziert werden, können auf gleicher Ebene wie Instanzvariablen stehen oder innerhalb von Methoden sein, ja, sie können sogar ein Teil eines Ausdrucks sein. Java-Innerklassen sind in Mitglieds-Innerklassen, lokale Innere Klassen und anonyme Innere Klassen unterteilt. Lassen Sie uns die anonyme Innere Klasse genauer betrachten.

A. Über Callback-Funktionen

Eine anonyme Innere Klasse verwendet Callback-Funktionen, was ist eine Callback-Funktion?

Unter Callback versteht man, dass das Client-Programm C eine Funktion A im Service-Programm S aufruft und S später wiederum eine Funktion B im C aufruft, für C ist diese B die Callback-Funktion. Zum Beispiel Win32Das Fenster-Prozess-Funktion ist eine typische Callback-Funktion. Im Allgemeinen ruft C nicht B selbst auf, sondern stellt B zur Verfügung, um von S aufgerufen zu werden, und das ist für C obligatorisch. Da S nicht weiß, wer die von C bereitgestellte B ist, vereinbart S die Schnittstellennormen (Funktionsprotokoll) von B und teilt C durch eine Funktion R mit, dass es die B-Funktion verwenden wird, was als Registrierung der Callback-Funktion bezeichnet wird, und R wird als Registrierungsfunktion bezeichnet. Web Service und Java RMI verwenden Callback-Mechanismen, um auf Remote Serverprogramme zuzugreifen. Unten wird ein Beispiel dazu gezeigt:

Der Programmierer A hat ein Programm (Programm a) geschrieben, darin sind Callback-Funktionsschnittstellen vorgesehen und das Programm wurde gut verpackt. Der Programmierer B möchte, dass a seine eigenen Methoden im Programm b aufruft, also ruft er durch die Schnittstelle in a die eigenen Methoden in b zurück. Das Ziel ist erreicht. In C/C++Darin muss eine Callback-Funktion verwendet werden, die Callback-Funktion muss der Aufrufer die Adresse des Zeigers mitteilen, aber in Java gibt es keine Zeiger, wie geht das? Wir können die Schnittstelle (interface) verwenden, um die Definition der Callback-Funktion zu realisieren.

Angenommen, ich bin der Programmierer A, hier ist mein Programm a:

public class Caller
{
  public MyCallInterface mc;
  public void setCallfuc(MyCallInterface mc)
  {
    this.mc= mc;
  }
  public void call(){
    this.mc.method();
  }
}

Ich muss eine Schnittstelle definieren, damit der Programmierer B nach meiner Definition die Software entwickeln kann, die die Schnittstelle implementiert.

public interface MyCallInterface
{
  public void method();
}

Daher muss der Programmierer B nur diese Schnittstelle implementieren, um das Ziel der Callback zu erreichen:

public class B implements MyCallInterface
{
  public void method()
  {
    System.out.println("Callback");
  }
  public static void main(String args[])
  {
    Caller call = new Caller();
    call.setCallfuc(new B());
    call.call();
  }
}

B. Über anonyme innere Klassen

Um zu verstehen, was eine innere Klasse ist, welche Funktionen eine innere Klasse hat, die Polymorphie in Java und was eine Callback-Funktion ist, gibt es viele detaillierte Erklärungen im Internet. Aus Gründen der Klarheit wurde nur eine einfache Erklärung gegeben. Eine anonyme innere Klasse wird als Parameter an eine Methode übergeben und in dieser Methode wird der Typ der Schnittstelle verwendet, um die übergebene anonyme Klasse zu akzeptieren, dann wird deren Methode aufgerufen, das ist Polymorphie. Der Grund ist, dass die Callback-Mechanismus implementiert wird. Weil er die Methode der anonymen inneren Klasse aufruft. Der folgende Code wurde manuell geschrieben und nicht getestet, nur zur Demonstration.

interface InterfaceA{
   String go();
}
class Test{
   public void prtGo(InterfaceA ia){
     System.out.println(ia.o());
   }
  public static void main(String []args){
     Test t = new Test();
     t.prtGo(new InterfaceA(){
       public String go(){
         return"go";
       }
     });
   }
}

更多关于Android相关内容感兴趣的读者可查看本站专题：《Android开发入门与进阶教程》、《Android调试技巧与常见问题解决方法汇总》、《Android多媒体操作技巧汇总(音频,视频,录音等)》、《Android基本组件用法总结》、《Android视图View技巧总结》、《Android布局layout技巧总结》及《Android控件用法总结》

希望本文所述对大家的Android程序设计有所帮助。

声明：本文内容来源于互联网，版权归原作者所有。内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：notice#oldtoolbag.com（在发送邮件时，请将#更换为@进行举报，并提供相关证据。一经查实，本站将立即删除涉嫌侵权内容。）