Mi az a beágyazott osztályok?

Beágyazott osztályok (nested classes) olyan osztályok, amelyeket egy másik osztályon belül deklarálnak. Lehetnek statikusak (static nested classes) vagy nem statikusak (inner classes).

Statikus beágyazott osztályok:

• A static módosítóval vannak deklarálva.
• Nem férnek hozzá közvetlenül a külső osztály nem statikus tagjaihoz (csak a külső osztály példányán keresztül).
• Tartalmazhatnak mind statikus, mind nem statikus tagokat.
• Külső osztály példánya nélkül hozhatók létre.

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

    public static class StaticNested {
        // Hozzáférés a staticOuterVar-hoz
        public void printStaticValue() {
            System.out.println(staticOuterVar);
        }

        // Nincs közvetlen hozzáférés az instanceOuterVar-hoz
        // public void printInstanceValue() {
        //     System.out.println(instanceOuterVar); // Fordítási hiba
        // }
    }
}

Statikus beágyazott osztály példánya:

// Példa a statikus beágyazott osztály példányosítására
Outer.StaticNested nestedObject = new Outer.StaticNested();
nestedObject.printStaticValue(); // 10-et ír ki

Nem statikus belső osztályok (Inner Classes):

• Nincs static módosítóval deklarálva.
• Teljes hozzáférésük van a külső osztály összes tagjához, beleértve a privátakat is.
• Nem tartalmazhatnak statikus tagokat (kivéve a konstansokat).
• A külső osztály példányának létrehozása szükséges a példányosításhoz.

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

    public class Inner {
        // Hozzáférés a staticOuterVar és az instanceOuterVar-hoz
        public void printValues() {
            System.out.println(staticOuterVar); // Elérhető
            System.out.println(instanceOuterVar); // Elérhető
        }
    }
}

Nem statikus belső osztály példányosítása:

// Nem statikus belső osztály példányosítása
Outer outerObject = new Outer();
Outer.Inner innerObject = outerObject.new Inner();
innerObject.printValues(); // 10 és 20-at ír ki

A belső osztályok használatának előnyei:

1. Logikai csoportosítás: Olyan osztályokat, amelyeket csak egy másik osztály használ, logikusan lehet csoportosítani benne.
2. Encapsuláció: A belső osztályok hozzáférnek a külső osztály privát tagjaihoz.
3. Olvashatóság és karbantartás: A kód rendezettebbé válik.

Nem statikus belső osztályok típusai:

• Helyi osztályok: Egy metóduson belül deklarálva.
• Anonim osztályok: Név nélküli osztályok, amelyeket általában absztrakt osztály, interfész vagy alap osztály példányosítására használnak, metódusok felülírásával.

Helyi osztály:

public class Outer {
    public void myMethod() {
        class LocalClass {
            void display() {
                System.out.println("Helyi osztályon belül");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

Névtelen osztály (interfész példával):

interface Greeting {
    void sayHello();
}

public class Outer {
    public void greet() {
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Üdvözlet névtelen osztályból!");
            }
        };
        anonymousGreeting.sayHello();
    }
}