Czym są klasy zagnieżdżone?

Klasy zagnieżdżone (nested classes) to klasy zadeklarowane wewnątrz innej klasy. Mogą być statyczne (static nested classes) lub niestatyczne (inner classes).

Statyczne klasy zagnieżdżone:

• Deklarowane ze słowem kluczowym static.
• Nie mają bezpośredniego dostępu do niestatycznych członków klasy zewnętrznej (tylko przez instancję klasy zewnętrznej).
• Mogą zawierać zarówno członków statycznych, jak i niestatycznych.
• Tworzone bez instancji klasy zewnętrznej.

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

    public static class StaticNested {
        // Ma dostęp do staticOuterVar
        public void printStaticValue() {
            System.out.println(staticOuterVar);
        }

        // Nie ma bezpośredniego dostępu do instanceOuterVar
        // public void printInstanceValue() {
        //     System.out.println(instanceOuterVar); // Błąd kompilacji
        // }
    }
}

Użycie klasy zagnieżdżonej statycznej:

// Przykład tworzenia instancji klasy zagnieżdżonej statycznej
Outer.StaticNested nestedObject = new Outer.StaticNested();
nestedObject.printStaticValue(); // Wypisze 10

Klasy wewnętrzne (Inner Classes):

• Nie deklaruje się ich ze słowem kluczowym static.
• Mają pełny dostęp do wszystkich członków klasy zewnętrznej, w tym prywatnych.
• Nie mogą zawierać członków statycznych (z wyjątkiem stałych czasu kompilacji).
• Wymagają utworzenia instancji klasy zewnętrznej.

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

    public class Inner {
        // Ma dostęp do staticOuterVar i instanceOuterVar
        public void printValues() {
            System.out.println(staticOuterVar); // Dostępne
            System.out.println(instanceOuterVar); // Dostępne
        }
    }
}

Użycie klasy wewnętrznej niestatycznej:

// Tworzenie instancji klasy wewnętrznej niestatycznej
Outer outerObject = new Outer();
Outer.Inner innerObject = outerObject.new Inner();
innerObject.printValues(); // Wypisze 10 i 20

Zalety używania klas zagnieżdżonych:

1. Logiczne grupowanie: Klasy używane tylko przez inną klasę można grupować wewnątrz niej.
2. Enkapsulacja: Klasy zagnieżdżone mają dostęp do prywatnych członków klasy zewnętrznej.
3. Czytelność i utrzymanie: Kod staje się bardziej uporządkowany.

Typy klas niestatycznych zagnieżdżonych:

• Klasy lokalne: Deklarowane wewnątrz metody.
• Klasy anonimowe: Klasy bez nazwy, zwykle używane do tworzenia instancji abstrakcyjnej klasy, interfejsu lub klasy bazowej z nadpisanymi metodami.

Klasa lokalna:

public class Outer {
    public void myMethod() {
        class LocalClass {
            void display() {
                System.out.println("Wewnątrz klasy lokalnej");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

Klasa anonimowa (przykład z interfejsem):

interface Greeting {
    void sayHello();
}

public class Outer {
    public void greet() {
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Cześć z klasy anonimowej!");
            }
        };
        anonymousGreeting.sayHello();
    }
}