Co jsou to vnořené třídy?

Vnořené třídy (nested classes) jsou třídy deklarované uvnitř jiné třídy. Mohou být statické (static nested classes) nebo nestatické (inner classes).

Statické vnořené třídy:

• Deklarují se s modifikátorem static.
• Nemají přímý přístup k nestatickým členům vnější třídy (pouze přes instanci vnější třídy).
• Mohou obsahovat jak statické, tak nestatické členy.
• Jsou vytvářeny bez instance vnější třídy.

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

    public static class StaticNested {
        // Má přístup k staticOuterVar
        public void printStaticValue() {
            System.out.println(staticOuterVar);
        }

        // Nemá přímý přístup k instanceOuterVar
        // public void printInstanceValue() {
        //     System.out.println(instanceOuterVar); // Chyba kompilace
        // }
    }
}

Použití statické vnořené třídy:

// Příklad vytvoření instance statické vnořené třídy
Outer.StaticNested nestedObject = new Outer.StaticNested();
nestedObject.printStaticValue(); // Vypíše 10

Neststatické vnořené třídy (Inner Classes):

• Deklarují se bez modifikátoru static.
• Mají plný přístup ke všem členům vnější třídy, včetně soukromých.
• Nemohou obsahovat statické členy (kromě konstant času kompilace).
• Vyžadují vytvoření instance vnější třídy pro jejich vytvoření.

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

    public class Inner {
        // Má přístup k staticOuterVar a instanceOuterVar
        public void printValues() {
            System.out.println(staticOuterVar); // Dostupné
            System.out.println(instanceOuterVar); // Dostupné
        }
    }
}

Vytvoření instance nestatické vnitřní třídy:

// Vytvoření instance nestatické vnitřní třídy
Outer outerObject = new Outer();
Outer.Inner innerObject = outerObject.new Inner();
innerObject.printValues(); // Vypíše 10 a 20

Výhody používání vnořených tříd:

1. Logická skupina: Třídy používané pouze jednou jinou třídou lze logicky seskupit uvnitř ní.
2. Zapouzdření: Vnořené třídy mají přístup k soukromým členům vnější třídy.
3. Čitelnost a údržba: Kód je lépe organizovaný.

Typy nestatických vnořených tříd:

• Lokální třídy: Deklarují se uvnitř metody.
• Anonymní třídy: Třídy bez zřejmého jména, obvykle používané k vytvoření instance abstraktní třídy, rozhraní nebo základní třídy s přepsáním metod.

Lokální třída:

public class Outer {
    public void myMethod() {
        class LocalClass {
            void display() {
                System.out.println("Uvnitř lokální třídy");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

Nekonkrétní třída (příklad s rozhraním):

interface Greeting {
    void sayHello();
}

public class Outer {
    public void greet() {
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Ahoj z anonymní třídy!");
            }
        };
        anonymousGreeting.sayHello();
    }
}