Wat zijn geneste klassen?

Geneste klassen (nested classes) zijn klassen die binnen een andere klasse zijn gedeclareerd. Ze kunnen statisch (static nested classes) of niet-statisch (inner classes) zijn.

Statische geneste klassen:

• Worden gedeclareerd met de modifier static.
• Hebben geen directe toegang tot de niet-statische leden van de externe klasse (alleen via een instantie van de externe klasse).
• Kunnen zowel statische als niet-statische leden bevatten.
• Worden gemaakt zonder een instantie van de externe klasse.

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

    public static class StaticNested {
        // Heeft toegang tot staticOuterVar
        public void printStaticValue() {
            System.out.println(staticOuterVar);
        }

        // Heeft geen directe toegang tot instanceOuterVar
        // public void printInstanceValue() {
        //     System.out.println(instanceOuterVar); // Compileerfout
        // }
    }
}

Gebruik van de statische geneste klasse:

// Voorbeeld van het maken van een instantie van de statische geneste klasse
Outer.StaticNested nestedObject = new Outer.StaticNested();
nestedObject.printStaticValue(); // Drukt 10 af

Inner classes:

• Worden niet gedeclareerd met static.
• Hebben volledige toegang tot alle leden van de externe klasse, inclusief private.
• Kunnen geen statische leden bevatten (behalve compileertijd constanten).
• Vereisen een instantie van de externe klasse voor creatie.

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

    public class Inner {
        // Heeft toegang tot staticOuterVar en instanceOuterVar
        public void printValues() {
            System.out.println(staticOuterVar); // Beschikbaar
            System.out.println(instanceOuterVar); // Beschikbaar
        }
    }
}

Gebruik van de inner class:

// Voorbeeld van het maken van een instantie van de inner class
Outer outerObject = new Outer();
Outer.Inner innerObject = outerObject.new Inner();
innerObject.printValues(); // Drukt 10 en 20 af

Voordelen van het gebruik van geneste klassen:

1. Logische groepering: Klassen die alleen door een andere klasse worden gebruikt, kunnen logisch binnen die klasse worden gegroepeerd.
2. Encapsulatie: Inner classes hebben toegang tot de private leden van de externe klasse.
3. Leesbaarheid en onderhoudbaarheid: De code wordt overzichtelijker.

Typen niet-statische inner classes:

• Lokale klassen: Worden binnen een methode gedeclareerd.
• Anonieme klassen: Klassen zonder expliciete naam, meestal gebruikt om instanties van abstracte klassen, interfaces of basisklassen met overschreven methoden te maken.

Lokale klasse:

public class Outer {
    public void myMethod() {
        class LocalClass {
            void display() {
                System.out.println("Binnen lokale klasse");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

Anoniete klasse (voorbeeld met interface):

interface Greeting {
    void sayHello();
}

public class Outer {
    public void greet() {
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hallo van anonieme klasse!");
            }
        };
        anonymousGreeting.sayHello();
    }
}