Esercizi sulle Classi Annidate in Java

Ecco degli esercizi con soluzione per praticare l’uso delle classi annidate in Java.

Esercizio 1: Classe Interna

Creare una classe interna semplice che accede ai membri della classe esterna.

public class Esterna {
    private String messaggio = "Ciao dal mondo esterno!";

    class Interna {
        public void stampaMessaggio() {
            System.out.println(messaggio);
        }
    }

    public static void main(String[] args) {
        Esterna esterna = new Esterna();
        Esterna.Interna interna = esterna.new Interna();
        interna.stampaMessaggio();
    }
}

Esercizio 2: Classe Annidata Statica

Creare una classe annidata statica e accedere ai membri statici della classe esterna.

public class EsternaStatica {
    private static String messaggio = "Ciao dal mondo esterno statico!";

    static class InternaStatica {
        public void stampaMessaggio() {
            System.out.println(messaggio);
        }
    }

    public static void main(String[] args) {
        EsternaStatica.InternaStatica interna = new EsternaStatica.InternaStatica();
        interna.stampaMessaggio();
    }
}

Esercizio 3: Classe Locale

Creare una classe locale all'interno di un metodo e accedere ai membri locali del metodo.

public class ClasseLocale {
    public void metodoConClasseLocale() {
        String messaggio = "Ciao dalla classe locale!";

        class Locale {
            public void stampaMessaggio() {
                System.out.println(messaggio);
            }
        }

        Locale locale = new Locale();
        locale.stampaMessaggio();
    }

    public static void main(String[] args) {
        ClasseLocale cl = new ClasseLocale();
        cl.metodoConClasseLocale();
    }
}

Esercizio 4: Classe Anonima

Creare una classe anonima che implementa un'interfaccia e sovrascrivere il metodo dell'interfaccia.

interface Saluto {
    void saluta();
}

public class ClasseAnonima {
    public void metodoClasseAnonima() {
        Saluto saluto = new Saluto() {
            @Override
            public void saluta() {
                System.out.println("Ciao dalla classe anonima!");
            }
        };
        saluto.saluta();
    }

    public static void main(String[] args) {
        ClasseAnonima ca = new ClasseAnonima();
        ca.metodoClasseAnonima();
    }
}

Esercizio 5: Accesso a Variabili Finali

Accedere a variabili locali finali da una classe interna locale.

public class VariabiliFinali {
    public void metodoConClasseLocale() {
        final String messaggio = "Variabile finale";

        class Locale {
            public void stampaMessaggio() {
                System.out.println(messaggio);
            }
        }

        Locale locale = new Locale();
        locale.stampaMessaggio();
    }

    public static void main(String[] args) {
        VariabiliFinali vf = new VariabiliFinali();
        vf.metodoConClasseLocale();
    }
}

Esercizio 6: Classe Interna Privata

Creare una classe interna privata e un metodo nella classe esterna per accedere ai suoi membri.

public class EsternaPrivata {
    private String messaggio = "Classe interna privata";

    private class InternaPrivata {
        public void stampaMessaggio() {
            System.out.println(messaggio);
        }
    }

    public void metodoAccediInterna() {
        InternaPrivata interna = new InternaPrivata();
        interna.stampaMessaggio();
    }

    public static void main(String[] args) {
        EsternaPrivata ep = new EsternaPrivata();
        ep.metodoAccediInterna();
    }
}

Esercizio 7: Classe Statica con Metodo Statica

Creare una classe annidata statica con un metodo statico e chiamarlo dalla classe esterna.

public class EsternaStaticaMetodo {
    static class InternaStatica {
        public static void metodoStatica() {
            System.out.println("Metodo statico della classe annidata");
        }
    }

    public static void main(String[] args) {
        EsternaStaticaMetodo.InternaStatica.metodoStatica();
    }
}

Esercizio 8: Classe Annidata con Costruttore

Creare una classe annidata con un costruttore che accetta parametri e creare un'istanza dalla classe esterna.

public class EsternaConCostruttore {
    class Interna {
        private String messaggio;

        public Interna(String messaggio) {
            this.messaggio = messaggio;
        }

        public void stampaMessaggio() {
            System.out.println(messaggio);
        }
    }

    public static void main(String[] args) {
        EsternaConCostruttore esterna = new EsternaConCostruttore();
        EsternaConCostruttore.Interna interna = esterna.new Interna("Ciao dalla classe interna con costruttore!");
        interna.stampaMessaggio();
    }
}