Quels sont les types de classes imbriquées?

Les classes imbriquées (Nested Classes) en Java se divisent en deux types principaux :

1. Classes imbriquées statiques (Static Nested Classes)

   • Marquées avec le modificateur static.
   • Se comportent comme des membres statiques normaux de la classe conteneur.
   • Peuvent accéder aux membres statiques de la classe externe (même s'ils sont privés).
   • N'ont pas accès directement aux membres non statiques de la classe externe.
   • Sont créées sans instance de la classe externe : OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();.

2. Classes internes (Inner Classes)

   Les classes internes ne sont pas marquées avec static et sont liées à une instance de la classe externe. Elles se subdivisent en :

   • Classes membres (Member Inner Classes)

     • Déclarées au niveau d'un membre de la classe conteneur, mais en dehors de ses méthodes.
     • Ont accès à tous les membres de la classe externe, y compris privés.
     • Nécessitent une instance de la classe externe pour créer leur propre instance : OuterClass outerObject = new OuterClass(); OuterClass.MemberInnerClass innerObject = outerObject.new MemberInnerClass();.

   • Classes locales (Local Classes)

     • Créées à l'intérieur de méthodes, constructeurs ou blocs d'initialisation.
     • Leur portée est limitée au bloc dans lequel elles sont déclarées.
     • Ne peuvent pas être déclarées avec des modificateurs d'accès (public, private, protected).
     • Peuvent accéder aux variables locales finales ou effectivement finales du bloc externe.
     • Ne peuvent pas être utilisées en dehors du bloc où elles sont définies.

   • Classes anonymes (Anonymous Classes)

     • Sont essentiellement des classes locales sans nom.
     • Sont déclarées et instanciées en même temps.
     • Sont utilisées pour implémenter une classe abstraite ou une interface "sur le vif".
     • Comme les classes locales, elles ont accès aux variables locales finales ou effectivement finales du bloc externe.

Exemple de structure :

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

    // Classe imbriquée statique
    static class StaticNestedClass {
        void accessOuter() {
            // Peut accéder aux membres statiques de la classe externe
            int value = staticOuterField;
            // Ne peut pas accéder aux membres non statiques
            // int value2 = outerField; // Erreur de compilation
        }
    }

    // Classe membre (classe interne)
    class MemberInnerClass {
        void accessOuter() {
            // Peut accéder à tous les membres de la classe externe
            int value1 = outerField;
            int value2 = staticOuterField;
        }
    }

    void methodWithLocalAndAnonymous() {
        final int localVar = 10; // final ou effectif final

        // Classe locale
        class LocalClass {
            void accessOuter() {
                // Peut accéder aux membres de la classe externe et variables locales finales/efficacement finales
                int value1 = outerField;
                int value2 = staticOuterField;
                int localValue = localVar;
            }
        }

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

        // Classe anonyme (implémentant Runnable)
        Runnable anonymousRunnable = new Runnable() {
            @Override
            public void run() {
                // Peut accéder aux membres de la classe externe et variables locales finales/efficacement finales
                int value1 = outerField;
                int value2 = staticOuterField;
                int localValue = localVar;
                System.out.println("Exécution avec variable locale : " + localValue);
            }
        };

        anonymousRunnable.run();
    }
}