Was sind verschachtelte Klassen?

Verschachtelte Klassen (nested classes) sind Klassen, die innerhalb einer anderen Klasse deklariert sind. Sie können statisch (static nested classes) oder nicht statisch (inner classes) sein.

Statische verschachtelte Klassen:

• Werden mit dem Modifikator static deklariert.
• Haben keinen direkten Zugriff auf die nicht-statischen Mitglieder der äußeren Klasse (nur über eine Instanz der äußeren Klasse).
• Können sowohl statische als auch nicht-statische Mitglieder enthalten.
• Werden ohne eine Instanz der äußeren Klasse erstellt.

public class Outer {
    private static int staticOuterVar = 10;
    private int instanceOuterVar = 20;

    public static class StaticNested {
        // Hat Zugriff auf staticOuterVar
        public void printStaticValue() {
            System.out.println(staticOuterVar);
        }

        // Hat keinen direkten Zugriff auf instanceOuterVar
        // public void printInstanceValue() {
        //     System.out.println(instanceOuterVar); // Kompilierungsfehler
        // }
    }
}

Verwendung der statischen verschachtelten Klasse:

// Beispiel für die Erstellung einer Instanz der statischen verschachtelten Klasse
Outer.StaticNested nestedObject = new Outer.StaticNested();
nestedObject.printStaticValue(); // Gibt 10 aus

Innere Klassen (Inner Classes):

• Werden nicht mit static deklariert.
• Haben vollen Zugriff auf alle Mitglieder der äußeren Klasse, einschließlich privater.
• Können keine statischen Mitglieder enthalten (außer Konstanten zur Kompilierungszeit).
• Erfordern eine Instanz der äußeren Klasse für ihre Erstellung.

public class Outer {
    private static int staticOuterVar = 10;
    private int instanceOuterVar = 20;

    public class Inner {
        // Hat Zugriff auf staticOuterVar und instanceOuterVar
        public void printValues() {
            System.out.println(staticOuterVar); // Verfügbar
            System.out.println(instanceOuterVar); // Verfügbar
        }
    }
}

Verwendung der inneren Klasse:

// Beispiel für die Erstellung einer Instanz der inneren Klasse
Outer outerObject = new Outer();
Outer.Inner innerObject = outerObject.new Inner();
innerObject.printValues(); // Gibt 10 und 20 aus

Vorteile der Verwendung verschachtelter Klassen:

1. Logische Gruppierung: Klassen, die nur von einer anderen Klasse verwendet werden, können logisch innerhalb dieser gruppiert werden.
2. Kapselung: Innere Klassen haben Zugriff auf die privaten Mitglieder der äußeren Klasse.
3. Lesbarkeit und Wartbarkeit: Der Code wird übersichtlicher.

Arten nicht-statischer innerer Klassen:

• Lokale Klassen: Innerhalb einer Methode deklariert.
• Anonyme Klassen: Klassen ohne expliziten Namen, die meist zur Instanziierung abstrakter Klassen, Interfaces oder Basisklassen mit überschriebenen Methoden verwendet werden.

Lokale Klasse:

public class Outer {
    public void myMethod() {
        class LocalClass {
            void display() {
                System.out.println("Innerhalb der lokalen Klasse");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

Anonyme Klasse (Beispiel mit Interface):

interface Greeting {
    void sayHello();
}

public class Outer {
    public void greet() {
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hallo aus der anonymen Klasse!");
            }
        };
        anonymousGreeting.sayHello();
    }
}