Was sind verschachtelte Klassen?

Eine verschachtelte Klasse ist eine Klasse, die innerhalb einer anderen Klasse definiert ist.

Arten verschachtelter Klassen in Java:

• Statische verschachtelte Klassen (Static Nested Classes):

  • Sind aus der äußeren Klasse ohne deren Instanz zugänglich.
  • Haben keinen direkten Zugriff auf nicht-statische Felder und Methoden der äußeren Klasse.
  • Werden mit dem Schlüsselwort static deklariert.

• Innere Klassen (Inner Classes):

  • Mitglieder-innere Klassen (Member Inner Classes):
    • Werden auf der Ebene der Mitglieder der äußeren Klasse deklariert.
    • Haben Zugriff auf alle Mitglieder der äußeren Klasse (einschließlich privat).
    • Benötigen eine Instanz der äußeren Klasse, um ihre Instanz zu erstellen.
  • Lokale innere Klassen (Local Inner Classes):
    • Werden innerhalb einer Methode, eines Konstruktors oder eines Initialisierungsblocks definiert.
    • Sind nur innerhalb dieser Methode/des Blocks sichtbar.
    • Haben Zugriff auf lokale Variablen, die final oder effektiv final sind.
  • Anonyme innere Klassen (Anonymous Inner Classes):
    • Klassen ohne Namen.
    • Werden verwendet, um Objekte zu erstellen, die sofort eine Schnittstelle implementieren oder eine Klasse erweitern.
    • Werden in einer einzigen Operation definiert und instanziiert.

Beispiel für eine statische verschachtelte Klasse:

class OuterClass {
    private static String msg = "Hello from Outer";

    static class StaticNestedClass {
        public void display() {
            // Kann auf statische Mitglieder der äußeren Klasse zugreifen
            System.out.println(msg);
        }
    }
}
// Verwendung
// OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
// nestedObject.display();

Beispiel für eine Mitglieder-innere Klasse:

class OuterClass {
    private String msg = "Hello from Outer";

    class InnerClass {
        public void display() {
            // Kann auf alle Mitglieder der äußeren Klasse zugreifen
            System.out.println(msg);
        }
    }
}
// Verwendung
// OuterClass outerObject = new OuterClass();
// OuterClass.InnerClass innerObject = outerObject.new InnerClass();
// innerObject.display();

Vorteile verschachtelter Klassen:

• Gruppierung: Logisch zusammenhängende Klassen können gruppiert werden.
• Kapselung: Innere Klassen können auf private Mitglieder der äußeren Klasse zugreifen, was die Kapselung verbessert.
• Lesbarkeit und Wartbarkeit: Verbergen Hilfsklassen innerhalb der Hauptklasse.
• Effizienz: Können verwendet werden, um kompaktere und effizientere Datenstrukturen zu erstellen.