Welche Arten von verschachtelten Klassen gibt es?

Verschachtelte Klassen (Nested Classes) in Java werden in zwei Haupttypen unterteilt:

1. Statische verschachtelte Klassen (Static Nested Classes)

   • Mit dem Modifikator static gekennzeichnet.
   • Verhält sich wie normale statische Mitglieder der Container-Klasse.
   • Können auf statische Mitglieder der äußeren Klasse zugreifen (auch wenn sie privat sind).
   • Haben keinen direkten Zugriff auf nicht-statische Mitglieder der äußeren Klasse.
   • Werden ohne Instanz der äußeren Klasse erstellt: OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();.

2. Innere Klassen (Inner Classes)

   Innere Klassen sind nicht mit static gekennzeichnet und sind mit einer Instanz der äußeren Klasse verbunden. Sie unterteilen sich in:

   • Mitgliedsklassen (Member Inner Classes)

     • Werden auf Ebene eines Mitglieds der Container-Klasse deklariert, aber außerhalb ihrer Methoden.
     • Haben Zugriff auf alle Mitglieder der äußeren Klasse, einschließlich privater.
     • Benötigen eine Instanz der äußeren Klasse, um ihre eigene Instanz zu erstellen: OuterClass outerObject = new OuterClass(); OuterClass.MemberInnerClass innerObject = outerObject.new MemberInnerClass();.

   • Lokale Klassen (Local Classes)

     • Werden innerhalb von Methoden, Konstruktoren oder Initialisierungsblöcken erstellt.
     • Ihre Sichtbarkeit ist auf den Block beschränkt, in dem sie deklariert sind.
     • Können nicht mit Zugriffsmodifikatoren (public, private, protected) deklariert werden.
     • Können auf final oder effektiv final lokale Variablen des äußeren Blocks zugreifen.
     • Können außerhalb des Blocks, in dem sie definiert sind, nicht verwendet werden.

   • Anonyme Klassen (Anonymous Classes)

     • Sind im Wesentlichen anonyme lokale Klassen.
     • Werden gleichzeitig deklariert und instanziiert.
     • Werden verwendet, um eine abstrakte Klasse oder Schnittstelle "on the fly" zu implementieren.
     • Haben, wie lokale Klassen, Zugriff auf final oder effektiv final lokale Variablen des äußeren Blocks.

Beispielstruktur:

class OuterClass {
    private int outerField;
    private static int staticOuterField;

    // Statische verschachtelte Klasse
    static class StaticNestedClass {
        void accessOuter() {
            // Kann auf statische Mitglieder der äußeren Klasse zugreifen
            int value = staticOuterField;
            // Kann nicht auf nicht-statische Mitglieder zugreifen
            // int value2 = outerField; // Compilerfehler
        }
    }

    // Mitgliedsklasse (innere Klasse)
    class MemberInnerClass {
        void accessOuter() {
            // Kann auf alle Mitglieder der äußeren Klasse zugreifen
            int value1 = outerField;
            int value2 = staticOuterField;
        }
    }

    void methodWithLocalAndAnonymous() {
        final int localVar = 10; // final oder effektiv final

        // Lokale Klasse
        class LocalClass {
            void accessOuter() {
                // Kann auf Mitglieder der äußeren Klasse und lokale final/effectively final Variablen zugreifen
                int value1 = outerField;
                int value2 = staticOuterField;
                int localValue = localVar;
            }
        }

        LocalClass localObj = new LocalClass();
        localObj.accessOuter();

        // Anonyme Klasse (implementiert Runnable)
        Runnable anonymousRunnable = new Runnable() {
            @Override
            public void run() {
                // Kann auf Mitglieder der äußeren Klasse und lokale final/effectively final Variablen zugreifen
                int value1 = outerField;
                int value2 = staticOuterField;
                int localValue = localVar;
                System.out.println("Ausführung mit lokaler Variablen: " + localValue);
            }
        };

        anonymousRunnable.run();
    }
}