Qu'est-ce que les classes imbriquées?

Les classes imbriquées (nested classes) sont des classes déclarées à l'intérieur d'une autre classe. Elles peuvent être statiques (static nested classes) ou non statiques (inner classes).

Classes imbriquées statiques :

• Déclarées avec le modificateur static.
• N'ont pas accès directement aux membres non statiques de la classe externe (seulement via une instance de la classe externe).
• Peuvent contenir des membres statiques et non statiques.
• Sont créées sans instance de la classe externe.

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

    public static class StaticNested {
        // A accès à staticOuterVar
        public void printStaticValue() {
            System.out.println(staticOuterVar);
        }

        // N'a pas accès direct à instanceOuterVar
        // public void printInstanceValue() {
        //     System.out.println(instanceOuterVar); // Erreur de compilation
        // }
    }
}

Utilisation de la classe imbriquée statique :

// Exemple de création d'une instance de la classe imbriquée statique
Outer.StaticNested nestedObject = new Outer.StaticNested();
nestedObject.printStaticValue(); // Affiche 10

Classes internes (Inner Classes) :

• Ne sont pas déclarées avec static.
• Ont un accès complet à tous les membres de la classe externe, y compris privés.
• Ne peuvent pas contenir de membres statiques (sauf constantes de temps de compilation).
• Nécessitent une instance de la classe externe pour être créées.

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

    public class Inner {
        // A accès à staticOuterVar et instanceOuterVar
        public void printValues() {
            System.out.println(staticOuterVar); // Disponible
            System.out.println(instanceOuterVar); // Disponible
        }
    }
}

Utilisation de la classe interne non statique :

// Exemple de création d'une instance de la classe interne non statique
Outer outerObject = new Outer();
Outer.Inner innerObject = outerObject.new Inner();
innerObject.printValues(); // Affiche 10 et 20

Avantages de l'utilisation des classes imbriquées :

1. Regroupement logique : Les classes utilisées uniquement par une autre classe peuvent être regroupées logiquement à l'intérieur.
2. Encapsulation : Les classes imbriquées ont accès aux membres privés de la classe externe.
3. Lisibilité et maintenabilité : Le code devient plus organisé.

Types de classes internes non statiques :

• Classes locales : Déclarées à l'intérieur d'une méthode.
• Classes anonymes : Classes sans nom explicite, généralement utilisées pour créer des instances d'une classe abstraite, d'une interface ou d'une classe de base avec des méthodes redéfinies.

Classe locale :

public class Outer {
    public void myMethod() {
        class LocalClass {
            void display() {
                System.out.println("À l'intérieur de la classe locale");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

Classe anonyme (exemple avec interface) :

interface Greeting {
    void sayHello();
}

public class Outer {
    public void greet() {
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Bonjour depuis la classe anonyme!");
            }
        };
        anonymousGreeting.sayHello();
    }
}