Kurze Analyse anonymer innerer Java-Instanzen

Anonyme Klassen sind Klassen, die keine Namen haben können und daher nicht referenziert werden können. Sie müssen zum Zeitpunkt der Erstellung als Teil der neuen Anweisung deklariert werden. Dies erfordert die Verwendung einer anderen Form einer neuen Anweisung, wie unten gezeigt: new Diese Form einer neuen Anweisung deklariert eine neue anonyme Klasse, die eine A-Klasse erweitert oder eine bestimmte Schnittstelle implementiert. Außerdem wird eine neue Instanz dieser Klasse erstellt und als Ergebnis der Anweisung zurückgegeben. Die zu erweiternde Klasse und die zu implementierende Schnittstelle sind die Operanden der neuen Anweisung, gefolgt vom Rumpf der anonymen Klasse. Wenn eine anonyme Klasse eine andere Klasse erweitert, kann ihr Rumpf auf die Mitglieder der Klasse zugreifen, ihre Methoden überschreiben usw., genau wie jede andere Standardklasse. Wenn eine anonyme Klasse eine Schnittstelle implementiert, muss ihr Körper die Methoden der Schnittstelle implementieren.
Java-Code

interface pr 
{ 
void print1(); 
} 
public class noNameClass 
{ 
public pr dest() 
{ 
return new pr(){ 
public void print1() 
{ 
System.out.println("Hello world!!"); 
} 
}; 
} 
public static void main(String args[]) 
{ 
noNameClass c = new noNameClass(); 
pr hw=c.dest(); 
hw.print1(); 
} 
}

pr kann auch eine Klasse sein, aber die Methode, die Sie extern aufrufen, muss in Ihrer Klasse oder Schnittstelle deklariert werden. Methoden innerhalb anonymer Klassen können nicht von außen aufgerufen werden In Java Der vielleicht am häufigsten verwendete Ort für anonyme Klassen ist das Hinzufügen von Listner zu Frame.
Wie folgt:
Java-Code

import java.awt.*; 
import java.awt.event.*; 
public class QFrame extends Frame { 
public QFrame() { 
this.setTitle(\"my application\"); 
addWindowListener(new WindowAdapter() { 
public void windowClosing(WindowEvent e) { 
dispose(); 
System.exit(0); 
} 
}); 
this.setBounds(10,10,200,200); 
} 
}

Die interne anonyme Klasse erstellt eine interne Klasse, gibt Ihnen jedoch keinen Namen, dh es gibt keine Variable, die auf die Instanz verweist.

new WindowAdapter() { 
public void windowClosing(WindowEvent e) { 
dispose(); 
System.exit(0); 
} 
}

Neu ist die Erstellung eines WindowAdapter-Objekts. Das folgende {} gibt an, dass die Operation in den Klammern auf dieses Standardobjekt wirkt und dem obigen Java-Programm ein Funktionskörper folgt.

Der Zweck dieser Verwendung besteht darin, eine Instanz eines Objekts zu erstellen und eine seiner Funktionen zu überschreiben. Sie finden es, indem Sie den WindowAdapter-Code öffnen. Es ist eine abstrakte Klasse. Es handelt sich um eine Implementierung der WindowListener-Schnittstelle. Der Parameter von Frame.addWindowListner(); ist ein WindowListner, und die Implementierung besteht darin, eine von WindowAdapter abgeleitete anonyme Klasse zu übergeben.
1. Wie kann man die Existenz einer anonymen Klasse feststellen? Ich kann den Namen nicht sehen, es fühlt sich an, als wäre es nur ein Objekt, das von new aus der übergeordneten Klasse erstellt wurde, und es gibt keinen Namen für die anonyme Klasse.
Schauen wir uns zuerst den Pseudocode an

abstract class Father(){ 
.... 
} 
public class Test{ 
Father f1 = new Father(){ .... } //这里就是有个匿名内部类 
}

Im Allgemeinen sollte bei einem neuen Objekt nach den Klammern ein Semikolon stehen, d. h. die Anweisung des neuen Objekts endet.

Aber es ist anders, wenn eine anonyme innere Klasse erscheint. Den Klammern folgen geschweifte Klammern, und die geschweiften Klammern enthalten die spezifische Implementierungsmethode des neuen Objekts.
Weil wir wissen, dass eine abstrakte Klasse nicht direkt neu sein kann, müssen wir zuerst eine Implementierungsklasse haben, bevor wir ihre Implementierungsklasse neu erstellen können.
Der obige Pseudocode bedeutet, dass new die Implementierungsklasse von Father ist. Diese Implementierungsklasse ist eine anonyme innere Klasse.
Tatsächlich kann die obige anonyme innere Klasse aufgeteilt werden als

class SonOne extends Father{ 
...//这里的代码和上面匿名内部类，大括号中的代码是一样的 
} 
public class Test{ 
Father f1 = new SonOne() ; 
}

2. Hinweise zu anonymen inneren Klassen

Beachten Sie, dass die Deklaration der anonymen Klasse zur Kompilierungszeit erfolgt und die Die Instanziierung erfolgt zur Laufzeit. Das bedeutet, dass eine neue Anweisung in einer for-Schleife mehrere Instanzen derselben anonymen Klasse erstellt, anstatt eine Instanz mehrerer verschiedener anonymer Klassen.
Beachten Sie bei der Verwendung anonymer innerer Klassen die folgenden Grundsätze:
·Anonyme innere Klassen können keine Konstruktoren haben.
·Anonyme innere Klassen können keine statischen Mitglieder, Methoden und Klassen definieren.
·Anonyme innere Klassen können nicht öffentlich, geschützt, privat oder statisch sein.
·Es kann nur eine Instanz einer anonymen inneren Klasse erstellt werden.
·Eine anonyme innere Klasse muss hinter new stehen und wird verwendet, um implizit eine Schnittstelle oder eine Klasse zu implementieren.
·Da anonyme innere Klassen lokale innere Klassen sind, gelten alle Einschränkungen für lokale innere Klassen für sie.
·Innere Klassen können nur auf statische Variablen oder statische Methoden äußerer Klassen zugreifen.
Dies gilt für anonyme Klassen und innere Klassen:
Manchmal verwenden wir einige innere Klassen und anonyme Klassen. Wenn dies in einer anonymen Klasse verwendet wird, bezieht sich dies auf die anonyme Klasse oder innere Klasse selbst. Wenn wir zu diesem Zeitpunkt die Methoden und Variablen der externen Klasse verwenden möchten, sollten wir den Klassennamen der externen Klasse hinzufügen
3. Die Rolle anonymer innerer Klassen
Die internen Klassen von Java sind im Wesentlichen dieselben Verschachtelte Klassen in C++ Unterschied: Verschachtelte Klassen in C++ haben keine Handles für Wrapper-Klassen. Es drückt nur das Konzept der Kapselung aus, aber die innere Klasse von Java ist anders, sie kann auf die Mitglieder der Wrapping-Klasse zugreifen (was bedeutet, dass sie ein Handle für die Wrapping-Klasse hat).
Anonyme innere Klassen sind eine vereinfachte Art, innere Klassen zu schreiben: return new Wrapper {
...
} ist äquivalent zu: Wrapped erweitert Wrapper {
...
}
return new Wrapped();
Ist dies die einzige Rolle anonymer innerer Klassen?
Betrachten Sie diesen Fall:

Es gibt eine Klasse Child, die nicht nur die count()-Methode von Parent erben möchte, sondern auch die count-Methode in der ICount-Schnittstelle implementieren möchte sollten wir das zu diesem Zeitpunkt tun? Innere Klassen können ins Spiel kommen:

interface ICount { 
int count(); 
} 
class Parent { 
int i = 0; 
int count() { 
return i++; 
} 
}

Sehen Sie sich diesen Code an

class Child extends Parent { 
ICount getCount() { 
return new ICount { 
int i = 0; 
int count() { 
return (i *= 2); 
} 
} 
} 
}

public static void main(String[] args) { 
theApp = new Analyzer(); 
SwingUtilities.invokeLater(new Runnable() { // Anonymous Runnable class 
// object 
public void run() { // Run method executed in thread 
theApp.creatGUI(); // Call static GUI creator 
} 
}); 
} 
public static void main(String[] args) { 
theApp = new Analyzer(); // 创建一个对象 
SwingUtilities.invokeLater(new Runnable() { // Anonymous Runnable class 
// 一个匿名内部类，他实现了一个线程 
// 原本这个方法是传一个Runnable类型参数 // 这里可以通过这种匿名类的方式来实现 
// object 
public void run() { // Run method executed in thread 
theApp.creatGUI(); // Call static GUI creator 
} 
}); 
}

Mehr Java für Verwandte Artikel zur kurzen Analyse anonymer innerer Klasseninstanzen. Bitte beachten Sie die chinesische PHP-Website!