Welke soorten geneste klassen bestaan er?

Geneste Klassen (Nested Classes) in Java worden onderverdeeld in twee hoofdtypen:

1. Statische geneste klassen (Static Nested Classes)

   • Gemarkeerd met de modifier static.
   • Gedragen zich als normale statische leden van de containerklasse.
   • Kunnen toegang krijgen tot de statische leden van de externe klasse (zelfs als ze privé zijn).
   • Hebben geen directe toegang tot de niet-statische leden van de externe klasse.
   • Worden zonder instantie van de externe klasse gemaakt: OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();.

2. Binnenklassen (Inner Classes)

   Binnenklassen zijn niet gemarkeerd met static en zijn gekoppeld aan een instantie van de externe klasse. Ze worden onderverdeeld in:

   • Lid-binnenklassen (Member Inner Classes)

     • Worden gedeclareerd op het niveau van een lid van de containerklasse, maar buiten haar methoden.
     • Hebben toegang tot alle leden van de externe klasse, inclusief privéleden.
     • Vereisen een instantie van de externe klasse om hun eigen instantie te maken: OuterClass outerObject = new OuterClass(); OuterClass.MemberInnerClass innerObject = outerObject.new MemberInnerClass();.

   • Lokale klassen (Local Classes)

     • Worden gemaakt binnen methoden, constructors of initialisatieblokken.
     • Hun bereik is beperkt tot het blok waarin ze zijn gedeclareerd.
     • Kunnen niet worden gedeclareerd met toegangsspecificaties (public, private, protected).
     • Kunnen toegang krijgen tot lokale variabelen die final of effectief final zijn van het externe blok.
     • Kunnen niet buiten het blok worden gebruikt waarin ze zijn gedefinieerd.

   • Anonieme klassen (Anonymous Classes)

     • Zijn in wezen lokale klassen zonder naam.
     • Worden gelijktijdig gedeclareerd en geïnstantieerd.
     • Worden gebruikt om een abstracte klasse of interface "on the fly" te implementeren.
     • Net als lokale klassen, hebben ze toegang tot lokale variabelen die final of effectief final zijn van het externe blok.

Voorbeeldstructuur:

class OuterClass {
    private int outerField;
    private static int staticOuterField;

    // Statische geneste klasse
    static class StaticNestedClass {
        void accessOuter() {
            // Kan toegang krijgen tot de statische leden van de externe klasse
            int value = staticOuterField;
            // Kan niet toegang krijgen tot niet-statische leden
            // int value2 = outerField; // Compileerfout
        }
    }

    // Lid-klasse (binnenklasse)
    class MemberInnerClass {
        void accessOuter() {
            // Kan toegang krijgen tot alle leden van de externe klasse
            int value1 = outerField;
            int value2 = staticOuterField;
        }
    }

    void methodWithLocalAndAnonymous() {
        final int localVar = 10; // final of effectief final

        // Lokale klasse
        class LocalClass {
            void accessOuter() {
                // Kan toegang krijgen tot leden van de externe klasse en lokale final/effectief final variabelen
                int value1 = outerField;
                int value2 = staticOuterField;
                int localValue = localVar;
            }
        }

        LocalClass localObj = new LocalClass();
        localObj.accessOuter();

        // Anonieme klasse (implementatie van Runnable)
        Runnable anonymousRunnable = new Runnable() {
            @Override
            public void run() {
                // Kan toegang krijgen tot leden van de externe klasse en lokale final/effectief final variabelen
                int value1 = outerField;
                int value2 = staticOuterField;
                int localValue = localVar;
                System.out.println("Uitvoeren met lokale variabele: " + localValue);
            }
        };

        anonymousRunnable.run();
    }
}