• Home
  • Docker
  • Kubernetes
  • LLMs
  • Java
  • Ubuntu
  • Maven
  • Big Data
  • Archived
Java | Classes internes (inner classes)
  1. Classes internes (inner classes)
  2. Classes internes statiques (static inner classes | static nested classes)
  3. Classes internes locales (local inner classes)
  4. Classes internes anonymes (anonymous inner classes)
    1. Définir une classe anonyme à partir d'une autre classe
    2. Définir une classe anonyme à partir d'une classe abstraite
    3. Définir une classe anonyme à partir d'une interface

  1. Classes internes (inner classes)
    Une classe interne est une classe définie à l'intérieur d'une autre classe (appelée classe externe).

    Notes :
    • Le compilateur va créer deux fichiers séparés :
      • Un fichier pour la classe externe (MyOuterClass.class),
      • et un autre fichier pour la classe interne (MyOuterClass$MyInnerClass.class).

    • La classe interne ne peut pas déclarer des attributs statiques ou des méthodes statiques.

      La classe interne est un membre non-statique de la classe externe, donc le seul moyen d'y accéder est à travers une instance de la classe externe. Ça ne fait pas de sens, donc, de déclarer des membres (attributs et méthodes) statiques pour la classe interne.

    • Pour déclarer (à l'intérieur de la classe externe) une variable de type de la classe interne, ou créer (à l'intérieur de la classe externe) une instance de la classe interne, il faut utiliser le nom de la classe interne comme on le fait pour les classes ordinaires.

      Il n'est pas possible d'instancier directement la classe interne dans une méthode statique de la classe externe. Le compilateur va afficher une erreur :

      Comme indiquer dans le message d'erreur du compilateur, il faut passer par une instance de la classe externe pour pouvoir instancier la classe interne :

    • Il n'est pas possible de déclarer directement une variable de la classe interne ou l'instancier (de l'extérieur de la classe externe) ; il faut toujours utiliser la classe externe pour référencer la classe interne, sinon le compilateur affichera une erreur :

    • Pour déclarer une variable qui référence la classe interne (de l'extérieur de la classe externe), il faut utiliser le nom de la classe externe concaténé (par un point) avec le nom de la classe interne.
    • Pour créer une instance de la classe interne (de l'extérieur de la classe externe), il faut passer par une instance de la classe externe.
    • La déclaration de la classe interne peut utiliser les modificateurs d'accès public, protected, private, ou eventuellement n'avoir aucun de ces modificateurs d'accès (dans ce cas elle aura l'accès default).

      Les règles de visibilités s'appliquent lorsque la classe interne est déclarée protected et private.
      Par exemple, il n'est pas possible de référencer (de l'extérieur de la classe externe) la classe interne s'elle est déclarée privée à la classe externe.

    • La déclaration de la classe interne peut utiliser les modificateurs d'accès abstract et final (l'un ou l'autre, mais pas les deux au même temps !).

    • Il est possible d'accéder aux attributs et méthodes de la classe externe à partir de la classe interne, de la même manière que cela est possible à partir des méthodes de la classe externe.

      Il faut cependant noter que si la classe interne déclare des attributs (ou des méthodes) avec les mêmes noms que ceux de la classe externe, alors dans ce cas il faut utiliser MyOuterClass.this pour référencer les attributs (et les méthodes) de la classe externe à partir de la classe interne. Au cas contraire, les attributs et les méthodes de la classe interne seront utilisées par la JVM.

      Attention le this référence toujours l'instance du code en cours d'exécution (peu importe que ce soit le code de la classe interne ou externe).
  2. Classes internes statiques (static inner classes | static nested classes)
    Une classe interne statique est une classe définie à l'intérieur d'une autre classe (classe externe).

    La classe interne statique est un membre statique de la classe externe.
    Ce qui veut dire qu'elle est accessible sans avoir besoin de créer une instance de la classe externe.

    Les règles que nous avons vues ci-dessus pour les classes internes non-statiques s'appliquent aussi sur les classes internes statiques.
    Voici quelques particularités des classes internes statiques :
    • La classe interne statique peut déclarer des membres (attributs et méthodes) statiques et non-statiques.

    • Il n'est pas nécessaire d'instancier ni la classe interne ni la classe externe pour accéder aux membres (attributs et méthodes) statiques de la classe interne statique.

    • Il n'est pas nécessaire d'instancier la classe externe pour créer une instance de la classe interne statique (de l'extérieur de la classe externe).

    • La classe interne statique ne peut pas accéder aux membres (attributs et méthodes) non-statiques de la classe externe.
  3. Classes internes locales (local inner classes)
    Une classe interne locale est une classe définie à l'intérieur d'une méthode.

    Notes :
    • Le compilateur va créer des fichiers séparés pour chaque classe interne locale.

      Dans cet exemple le compilateur va créer les fichiers ".class" suivants :
      • MyTest3.class
      • MyTest3$1MyLocalInnerClass1.class
      • MyTest3$1MyLocalInnerClass2.class

    • La déclaration de la classe locale peut utiliser seulement les modificateurs d'accès abstract ou final (l'un ou l'autre, mais pas les deux au même temps !). Le compilateur va afficher une erreur si la déclaration de la classe contient, par exemple, le mot clé public :

    • La classe locale n'est visible que pour le code de la méthode où elle est définie ; elle peut être référée et instanciée uniquement à l'intérieur de ce code. Attention, seulement le code de la méthode qui est saisie après la définition de la classe locale peut référer et instancier la classe locale. Le compilateur va afficher une erreur si ce n'est pas le cas :

    • La classe locale peut déclarer seulement des membres (attributs et méthodes) non-statiques. Le compilateur va afficher une erreur si ce n'est pas le cas :

    • Les classes locales définies dans des méthodes statiques ne peuvent accéder qu'aux membres statiques des classes externes. Le compilateur va afficher une erreur si ce n'est pas le cas :

      Par contre, les classes locales définies dans des méthodes non-statiques peuvent accéder aux membres statiques et non-statiques des classes externes.

    • La classe locale peut accéder uniquement aux variables de la méthode qui sont déclarées avec le mot clé final. Le compilateur va afficher une erreur si ce n'est pas le cas :
  4. Classes internes anonymes (anonymous inner classes)
    Les classes internes anonymes sont des classes définies à partir de d'autres classes ou interfaces.

    Les classes anonymes n'ont pas de noms.

    La classe interne anonyme est utilisée pour re-définir une classe ou implémenter une interface lors d'une opération d'instanciation.

    La définition d'une classe interne anonyme est possible dans tout le code de la classe externe ; là où l'instanciation d'une classe est possible.

    1. Définir une classe anonyme à partir d'une autre classe

      Dans cet exemple, une nouvelle classe anonyme est créée à partir de la classe Object :
      la nouvelle classe anonyme hérite implicitement de la classe Object et peut ainsi redéfinir ses méthodes et peut aussi définir de nouvelles méthodes mais ces nouvelles méthodes seront visibles uniquement dans le code de la classe anonyme.

      La raison de cette restriction est due au fait que l'instance créée à partir de la classe anonyme est référée par une variable dont le type est celui de la classe Object et donc le compilateur va se plaindre si vous essayer d'appeler les nouvelles méthodes définies dans la classe anonyme :

      Il est possible de définir une classe anonyme comme argument d'une méthode :

      Notes :
      Le compilateur va créer des fichiers séparés pour chaque classe interne anonyme.

      Dans cet exemple le compilateur va créer les fichiers ".class" suivants :
      • MyTest4.class
      • MyTest4$1.class
      • MyTest4$2.class
    2. Définir une classe anonyme à partir d'une classe abstraite
      La classe anonyme doit implémenter toutes les méthodes abstraites de la classe abstraite.

    3. Définir une classe anonyme à partir d'une interface
      La classe anonyme peut implémenter une seule interface.
      Comme pour les classes abstraites, la classe anonyme doit implémenter toutes les méthodes de l'interface.

© 2025  mtitek