Welche Arten von verschachtelten Klassen gibt es…

Statische verschachtelte Klassen und innere Klassen (nicht-statische verschachtelte Klassen).

Statische verschachtelte Klassen:

Werden mit dem Schlüsselwort static deklariert.
Haben nur Zugriff auf statische Mitglieder (Felder und Methoden) der äußeren Klasse, einschließlich privater.
Haben keinen direkten Zugriff auf nicht-statische Mitglieder der äußeren Klasse.
Können ohne Instanz der äußeren Klasse instanziiert werden.

class Outer {
    private static int staticVar = 10;
    private int instanceVar = 20;

    static class StaticNested {
        void display() {
            System.out.println("Statische Variable: " + staticVar);
            // System.out.println("Instanzvariable: " + instanceVar); // Kompilierungsfehler
        }
    }
}

Innere Klassen (nicht-statische verschachtelte Klassen):
- Werden ohne das Schlüsselwort static deklariert.
- Haben vollen Zugriff auf alle Mitglieder (statische und nicht-statische) der äußeren Klasse, einschließlich privater.
- Können keine statischen Mitglieder (Felder oder Methoden) enthalten, außer finalen Konstanten.
- Erfordern eine Instanz der äußeren Klasse für ihre Erstellung.
```
class Outer {
    private static int staticVar = 10;
    private int instanceVar = 20;

    class Inner {
        void display() {
            System.out.println("Statische Variable: " + staticVar);
            System.out.println("Instanzvariable: " + instanceVar);
        }
    }
}
```

Lokale Klassen:

Werden innerhalb von Methoden, Konstruktoren oder Initialisierungsblöcken deklariert.
Haben Zugriff auf alle finalen und effektiv finalen lokalen Variablen sowie auf die Mitglieder der äußeren Klasse, in der sie definiert sind.
Ihr Sichtbarkeitsbereich ist auf den Block beschränkt, in dem sie deklariert sind.

class Outer {
    void myMethod() {
        final int localVar = 5; // Effektiv final

        class LocalInner {
            void display() {
                System.out.println("Lokale Variable: " + localVar);
            }
        }

        LocalInner local = new LocalInner();
        local.display();
    }
}

Anonyme Klassen:

Lokale Klassen ohne Namen.
Werden gleichzeitig erstellt und instanziiert.
Werden häufig verwendet, um Implementierungen von Schnittstellen zu erstellen oder Klassen zu erweitern.

interface MyInterface {
    void doSomething();
}

class Outer {
    void myMethod() {
        MyInterface anon = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("Anonyme Aktion.");
            }
        };
        anon.doSomething();
    }
}

Hauptunterschiede zwischen statischen verschachtelten Klassen und inneren Klassen:

Eigenschaft	Statische verschachtelte Klasse	Innere Klasse
Schlüsselwort	`static`	Nicht vorhanden
Zugriff auf Mitglieder	Nur auf statische Mitglieder der	Alle Mitglieder der äußeren Klasse
	äußeren Klasse
Instanziierung	Ohne Instanz der äußeren Klasse	Erfordert eine Instanz der äußeren Klasse
Statische Mitglieder	Können enthalten	Können keine enthalten (außer Konstanten)

Welche Arten von verschachtelten Klassen gibt es?