Cosa sono le classi annidate?

Le classi annidate (nested classes) sono classi dichiarate all'interno di un'altra classe. Possono essere statiche (static nested classes) o non statiche (inner classes).

Classi annidate statiche:

• Sono dichiarate con il modificatore static.
• Non hanno accesso diretto ai membri non statici della classe esterna (solo tramite un'istanza della classe esterna).
• Possono contenere membri statici e non statici.
• Vengono create senza un'istanza della classe esterna.

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

    public static class StaticNested {
        // Ha accesso a staticOuterVar
        public void printStaticValue() {
            System.out.println(staticOuterVar);
        }

        // Non ha accesso diretto a instanceOuterVar
        // public void printInstanceValue() {
        //     System.out.println(instanceOuterVar); // Errore di compilazione
        // }
    }
}

Utilizzo della classe annidata statica:

// Esempio di creazione di un'istanza di classe annidata statica
Outer.StaticNested nestedObject = new Outer.StaticNested();
nestedObject.printStaticValue(); // Stampa 10

Classi interne (Inner Classes):

• Non sono dichiarate con static.
• Hanno accesso completo a tutti i membri della classe esterna, inclusi quelli privati.
• Non possono contenere membri statici (eccetto costanti di compilazione).
• Richiedono un'istanza della classe esterna per essere create.

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

    public class Inner {
        // Ha accesso a staticOuterVar e instanceOuterVar
        public void printValues() {
            System.out.println(staticOuterVar); // Disponibile
            System.out.println(instanceOuterVar); // Disponibile
        }
    }
}

Utilizzo della classe interna non statica:

// Esempio di creazione di un'istanza di classe interna non statica
Outer outerObject = new Outer();
Outer.Inner innerObject = outerObject.new Inner();
innerObject.printValues(); // Stampa 10 e 20

Vantaggi dell'uso di classi annidate:

1. Gruppo logico: Le classi usate solo da un'altra classe possono essere raggruppate logicamente all'interno di essa.
2. Incapsulamento: Le classi annidate hanno accesso ai membri privati della classe esterna.
3. Leggibilità e manutenibilità: Il codice diventa più ordinato.

Tipi di classi interne non statiche:

• Classi locali: Dichiarate all'interno di un metodo.
• Classi anonime: Classi senza nome esplicito, usate di solito per creare istanze di classi astratte, interfacce o classi base con metodi sovrascritti.

Classe locale:

public class Outer {
    public void myMethod() {
        class LocalClass {
            void display() {
                System.out.println("All'interno della classe locale");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

Classe anonima (esempio con interfaccia):

interface Greeting {
    void sayHello();
}

public class Outer {
    public void greet() {
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Ciao dalla classe anonima!");
            }
        };
        anonymousGreeting.sayHello();
    }
}