Čo sú to vnorené triedy?

Vnorené triedy (nested classes) sú triedy, ktoré sú deklarované v rámci inej triedy. Môžu byť statické (static nested classes) alebo nestatické (inner classes).

Statické vnorené triedy:

• Deklarujú sa s modifikátorom static.
• Nemajú priamy prístup k nestatickým členom vonkajšej triedy (len cez inštanciu vonkajšej triedy).
• Môžu obsahovať ako statické, tak nestatické členy.
• Sú vytvorené bez inštancie vonkajšej triedy.

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

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

        // Nemá priamy prístup k instanceOuterVar
        // public void printInstanceValue() {
        //     System.out.println(instanceOuterVar); // Chyba kompilácie
        // }
    }
}

Použitie statickej vnorenej triedy:

// Príklad vytvorenia inštancie statickej vnorenej triedy
Outer.StaticNested nestedObject = new Outer.StaticNested();
nestedObject.printStaticValue(); // Vypíše 10

Nestatické vnorené triedy (Inner Classes):

• Deklarujú sa bez modifikátora static.
• Majú plný prístup ku všetkým členom vonkajšej triedy, vrátane súkromných.
• Nemôžu obsahovať statické členy (okrem konštánt počas kompilácie).
• Na ich vytvorenie je potrebná inštancia vonkajšej triedy.

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

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

Vytvorenie inštancie nestatickej vnútornej triedy:

// Vytvorenie inštancie nestatickej vnútornej triedy
Outer outerObject = new Outer();
Outer.Inner innerObject = outerObject.new Inner();
innerObject.printValues(); // Vypíše 10 a 20

Výhody používania vnorených tried:

1. Logická skupina: Triedy, ktoré sa používajú iba od inej triedy, môžu byť logicky zoskupené v nej.
2. Zapuzdrovanie: Vnorené triedy majú prístup k súkromným členom vonkajšej triedy.
3. Čitateľnosť a údržba: Kód je organizovanejší.

Typy nestatických vnorených tried:

• Lokálne triedy: Deklarujú sa v rámci metódy.
• Nekonkrétne triedy (Anonymous classes): Triedy bez názvu, zvyčajne sa používajú na vytvorenie inštancie abstraktnej triedy, rozhrania alebo základnej triedy s prepísanými metódami.

Lokálna trieda:

public class Outer {
    public void myMethod() {
        class LocalClass {
            void display() {
                System.out.println("Vo vnútri lokálnej triedy");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

Nekonkrétna trieda (prí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 anonymnej triedy!");
            }
        };
        anonymousGreeting.sayHello();
    }
}