Anonyme Klassen sind Klassen, die keine Namen haben können, daher gibt es keine Möglichkeit, auf sie zu verweisen. Sie müssen zum Zeitpunkt der Erstellung als Teil der neuen Anweisung deklariert werden. Dies erfordert eine andere Form einer neuen Anweisung wie folgt: new <class or interface> <body of class> Diese Form einer neuen Anweisung deklariert eine neue anonyme Klasse, die eine bestimmte 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
Kopieren Sie den Codecode wie folgt:
Schnittstelle pr
{
void print1();
}
öffentliche Klasse noNameClass
{
öffentliches PR dest()
{
neues pr(){ zurückgeben
public void print1()
{
System.out.println("Hallo Welt!!");
}
};
}
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 der anonymen Klasse können nicht von außen aufgerufen werden.
Der vielleicht am häufigsten verwendete Ort für interne anonyme Klassen in Java ist das Hinzufügen von Listner zu Frame.
wie folgt:
Java-Code
Kopieren Sie den Codecode wie folgt:
java.awt.* importieren;
import java.awt.event.*;
öffentliche Klasse QFrame erweitert Frame {
öffentlicher QFrame() {
this.setTitle(/"meine Bewerbung/");
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
entsorgen();
System.exit(0);
}
});
this.setBounds(10,10,200,200);
}
}
Eine interne anonyme Klasse erstellt eine interne Klasse, gibt Ihnen jedoch keinen Namen, dh es gibt keine Variable, die auf die Instanz verweist.
Kopieren Sie den Codecode wie folgt:
neuer WindowAdapter() {
public void windowClosing(WindowEvent e) {
entsorgen();
System.exit(0);
}
}
Neu besteht darin, ein WindowAdapter-Objekt zu erstellen, und das folgende {} gibt an, dass die Operation in Klammern auf den Standardobjektnamen wirkt, und das Folgende im obigen Java-Programm ist ein Funktionskörper.
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 die Existenz einer anonymen Klasse festgestellt werden? 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 zunächst den Pseudocode an
Kopieren Sie den Codecode wie folgt:
abstrakte Klasse Father(){
....
}
öffentlicher Klassentest{
Father f1 = new Father(){ .... } //Hier gibt es eine anonyme innere Klasse
}
Im Allgemeinen sollte bei einem neuen Objekt nach den Klammern ein Semikolon stehen, d. h. die Anweisung des neuen Objekts endet.
Anders verhält es sich jedoch, wenn anonyme innere Klassen vorhanden sind. 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. Es muss eine Implementierungsklasse geben, bevor wir ihre Implementierungsklasse neu erstellen können.
Der obige Pseudocode zeigt an, dass new die Implementierungsklasse von Father ist und diese Implementierungsklasse eine anonyme innere Klasse ist.
Tatsächlich kann die Aufteilung der oben genannten anonymen inneren Klasse erfolgen
Kopieren Sie den Codecode wie folgt:
Klasse SonOne erweitert Father{
...//Der Code hier ist derselbe wie die anonyme innere Klasse oben, der Code in geschweiften Klammern
}
öffentlicher Klassentest{
Vater f1 = new SonOne();
}
2. Vorsichtsmaßnahmen für anonyme innere Klassen Beachten Sie, dass die Deklaration anonymer Klassen zur Kompilierungszeit und die Instanziierung zur Laufzeit erfolgt. 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 es sich bei anonymen inneren Klassen um lokale innere Klassen handelt, wirken sich alle Einschränkungen für lokale innere Klassen auf sie aus.
・Innere Klassen können nur auf statische Variablen oder statische Methoden äußerer Klassen zugreifen.
Dies in anonymen Klassen und inneren 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 inneren Klassen von Java unterscheiden sich grundlegend von den verschachtelten Klassen in C++: Die verschachtelten Klassen von 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 {
...
};
Entspricht: Wrapped erweitert Wrapper {
...
}
return new Wrapped();
Ist dies die einzige Rolle anonymer innerer Klassen?
Betrachten Sie diesen Fall:
Kopieren Sie den Codecode wie folgt:
Schnittstelle ICount {
int count();
}
Klasse Parent {
int i = 0;
int count() {
return i++;
}
}
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. Innere Klassen können ins Spiel kommen:
Kopieren Sie den Codecode wie folgt:
Klasse Child erweitert Parent {
ICount getCount() {
neues ICount zurückgeben {
int i = 0;
int count() {
return (i *= 2);
}
}
}
}
Schauen Sie sich diesen Code an
Kopieren Sie den Codecode wie folgt:
public static void main(String[] args) {
theApp = new Analyzer();
SwingUtilities.invokeLater(new Runnable() { // Anonyme ausführbare Klasse
// Objekt
public void run() { // Im Thread ausgeführte Methode ausführen
theApp.creatGUI(); // Statischen GUI-Ersteller aufrufen
}
});
}
public static void main(String[] args) {
theApp = new Analyzer(); // Ein Objekt erstellen
SwingUtilities.invokeLater(new Runnable() { // Anonyme ausführbare Klasse
// Eine anonyme innere Klasse, die einen Thread implementiert
// Ursprünglich sollte diese Methode einen Runnable-Typparameter übergeben // Dies kann durch diese anonyme Klassenmethode erreicht werden
// Objekt
public void run() { // Im Thread ausgeführte Methode ausführen
theApp.creatGUI(); // Statischen GUI-Ersteller aufrufen
}
});
}
