Vertel over geneste klassen en in welke gevallen ze…

Geneste classes (Nested Classes) in Java zijn classes die binnen een andere class zijn gedefinieerd. Ze worden onderverdeeld in twee types: statische (Static Nested Classes) en interne classes (Inner Classes).

Statische geneste classes

Worden gedeclareerd met de modifier static.
Hebben alleen toegang tot de statische leden van de externe class (zelfs de verborgen).
Hebben geen toegang tot de niet-statische leden van de externe class.

Om een instantie van een statische geneste class te maken, is geen instantie van de externe class nodig:

// Externe class
class Outer {
    static int outerStaticField;
    int outerInstanceField;

    // Statische geneste class
    static class StaticNested {
        void accessOuter() {
            // Toegang tot het statische veld van de externe class
            System.out.println(Outer.outerStaticField);
            // Geen toegang tot outerInstanceField
            // System.out.println(outerInstanceField); // Compileerfout
        }
    }
}

// Gebruik van de statische geneste class
class Main {
    public static void main(String[] args) {
        Outer.StaticNested nestedObject = new Outer.StaticNested();
        nestedObject.accessOuter();
    }
}

Inner classes

Worden niet gedeclareerd met de static modifier.
Hebben volledige toegang tot alle leden van de externe class (zowel statisch als niet-statisch, zelfs de verborgen).
Een instantie van een inner class kan niet bestaan zonder een instantie van de externe class.

Om een instantie van een inner class te maken, is een instantie van de externe class nodig:

// Externe class
class Outer {
    static int outerStaticField;
    int outerInstanceField;

    // Inner class
    class Inner {
        void accessOuter() {
            // Toegang tot het statische veld van de externe class
            System.out.println(Outer.outerStaticField);
            // Toegang tot het niet-statische veld van de externe class
            System.out.println(outerInstanceField);
        }
    }
}

// Gebruik van de inner class
class Main {
    public static void main(String[] args) {
        Outer outerObject = new Outer();
        Outer.Inner innerObject = outerObject.new Inner();
        innerObject.accessOuter();
    }
}

Inner classes worden onderverdeeld in:

Reguliere inner classes: Gedefinieerd direct binnen de body van de externe class.

Lokale inner classes: Gedefinieerd binnen methoden, constructors of initialisatieblokken. Alleen zichtbaar binnen dat blok.

class Outer {
    void display() {
        class LocalInner { // Lokale inner class
            void message() {
                System.out.println("Lokale inner class");
            }
        }
        LocalInner obj = new LocalInner();
        obj.message();
    }
}

Anonieme inner classes: Klassen zonder naam, gebruikt om een instantie van een klasse of interface te maken en direct hun implementatie te bieden. Vaak gebruikt met event listeners.

interface Greeting {
    void sayHello();
}

class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() { // Anonieme inner class
            @Override
            public void sayHello() {
                System.out.println("Hallo!");
            }
        };
        greeting.sayHello();
    }
}

Wanneer worden geneste classes toegepast:

Logische groepering: Als de class slechts deel uitmaakt van een andere class en het logisch is om ze samen te groeperen. Dit verbetert de leesbaarheid en onderhoudbaarheid van de code.
Encapsulatie: Geneste classes kunnen toegang hebben tot de leden van de externe class, wat een sterkere binding en het verbergen van implementatiedetails mogelijk maakt.
Betere code: Wanneer een kleine, eenvoudige class slechts op één plek wordt gebruikt, kan het insluiten ervan de code netter maken.
Efficiënt gebruik van bronnen: Inner classes hebben toegang tot de leden van de externe class zonder ze expliciet door te geven, wat de code kan vereenvoudigen. Een voorbeeld hiervan is de implementatie van iterators.
Implementatie van interfaces of uitbreiding van classes in de context: Anonieme inner classes worden vaak gebruikt om compacte implementaties van interfaces of abstracte classes "on the fly" te bieden.
Verbergen van implementatie: Het verbergen van een class binnen een andere class, waardoor deze niet zichtbaar is van buitenaf.

Vergelijking tussen statische geneste en inner classes:

Parameter	Statische geneste class	Inner class
`static` modifier	Ja	Nee
Toegang tot leden van de externe class	Alleen statisch (zelfs private)	Alle leden (statisch en niet-statisch, private)
Vereist een instantie van de externe class voor creatie	Nee	Ja
Relatie met instantie van de externe class	Nee	Ja

De keuze tussen een statische geneste class en een inner class hangt af van of de geneste class toegang nodig heeft tot niet-statische leden van de externe class. Als dat zo is, gebruik dan een inner class. Zo niet, dan is een statische geneste class geschikter omdat deze niet verbonden is met een instantie van de externe class en mogelijk efficiënter is.

Vertel over geneste klassen en in welke gevallen ze worden toegepast.