Classe intérieure - Inner class
Dans la programmation orientée objet (POO), une classe interne ou une classe imbriquée est une classe déclarée entièrement dans le corps d'une autre classe ou interface. Il se distingue d'une sous - classe .
Aperçu
Une instance d'une classe normale ou de niveau supérieur peut exister seule. En revanche, une instance d'une classe interne ne peut pas être instanciée sans être liée à une classe de niveau supérieur.
Prenons la notion abstraite de a Car
avec quatre Wheel
s. Nos Wheel
s ont une caractéristique spécifique qui repose sur leur appartenance Car
. Cette notion ne représente pas les Wheel
s en tant que Wheel
s sous une forme plus générale qui pourrait faire partie de n'importe quel véhicule. Au lieu de cela, il les représente comme spécifiques à un Car
. Nous pouvons modéliser cette notion en utilisant des classes internes comme suit:
Nous avons la classe de haut niveau Car
. Les instances de classe Car
sont composées de quatre instances de la classe Wheel
. Cette implémentation particulière de Wheel
est spécifique à une voiture, le code ne modélise donc pas la notion générale de roue qui serait mieux représentée comme une classe de haut niveau. Par conséquent, il est sémantiquement connecté à la classe Car
et le code de Wheel
est en quelque sorte couplé à sa classe externe, étant une unité de composition d'une voiture. La roue d'une voiture particulière est unique à cette voiture, mais à des fins de généralisation, la roue est une unité d'agrégation de la voiture.
Les classes internes fournissent un mécanisme pour modéliser avec précision cette connexion. On peut se référer à notre Wheel
classe Car.Wheel
, Car
étant la classe de niveau supérieur et Wheel
étant la classe interne.
Les classes internes permettent donc l'orientation objet de certaines parties du programme qui autrement ne seraient pas encapsulées dans une classe.
Les segments de code plus volumineux au sein d'une classe peuvent être mieux modélisés ou refactorisés en tant que classe de premier niveau distincte, plutôt qu'en classe interne. Cela rendrait le code plus général dans son application et donc plus réutilisable, mais pourrait être une généralisation prématurée. Cela peut s'avérer plus efficace si le code comporte de nombreuses classes internes avec la fonctionnalité partagée.
Types de classes imbriquées en Java
En Java, il existe quatre types de classes imbriquées :
- Statique
- Classe membre statique, également appelée classes imbriquées statiques - Elles sont déclarées
static
. Comme d'autres choses dans la portée statique (c'est-à-dire les méthodes statiques ), elles n'ont pas d'instance englobante et ne peuvent pas accéder aux variables d'instance et aux méthodes de la classe englobante. Elles sont presque identiques aux classes non imbriquées sauf pour les détails de portée (elles peuvent faire référence à des variables statiques et des méthodes de la classe englobante sans qualifier le nom; les autres classes qui ne font pas partie de ses classes englobantes doivent qualifier son nom avec ses classes englobantes Nom). Les interfaces imbriquées sont implicitement statiques.
- Classes non statiques / internes
Classe interne - Les catégories suivantes sont appelées classes internes . Chaque instance de ces classes a une référence à une instance englobante (c'est-à-dire une instance de la classe englobante), à l'exception des classes locales et anonymes déclarées dans un contexte statique. Par conséquent, ils peuvent implicitement faire référence aux variables d'instance et aux méthodes de la classe englobante. La référence d'instance englobante peut être explicitement obtenue via EnclosingClassName.this
. Les classes internes peuvent ne pas avoir de variables ou de méthodes statiques, à l'exception des variables constantes au moment de la compilation. Lorsqu'ils sont créés, ils doivent avoir une référence à une instance de la classe englobante; ce qui signifie qu'ils doivent soit être créés dans une méthode d'instance ou un constructeur de la classe englobante, soit (pour les classes membres et anonymes) être créés à l'aide de la syntaxe enclosingInstance.new InnerClass()
.
- Classe de membre - Ils sont déclarés en dehors d'une fonction (d'où un "membre") et non déclarés "statiques".
- Classe locale - Ce sont des classes qui sont déclarées dans le corps d'une fonction. Ils ne peuvent être mentionnés que dans le reste de la fonction. Ils peuvent utiliser des variables locales et des paramètres de la fonction, mais un seul qui est déclaré "final". (C'est parce que l'instance de classe locale doit conserver une copie séparée de la variable, car elle peut survivre à la fonction; afin de ne pas avoir la confusion de deux variables modifiables avec le même nom dans la même portée, la variable est forcée non modifiable.) Peut être très utile pour créer une classe avec des champs de type générique, où les variables de type sont définies dans la méthode.
- Classe anonyme - Ce sont des classes locales qui sont automatiquement déclarées et instanciées au milieu d'une expression. Ils ne peuvent étendre directement qu'une classe ou implémenter une interface. Ils peuvent spécifier des arguments pour le constructeur de la superclasse, mais ne peuvent pas autrement avoir de constructeur (cependant, ce n'est pas une limitation, car il peut avoir un bloc d'initialisation d'instance pour effectuer toute initialisation).
Langages de programmation
- Les classes internes sont devenues une fonctionnalité du langage de programmation Java à partir de la version 1.1.
- Les classes imbriquées sont également une fonctionnalité du langage de programmation D , Visual Basic .NET , Ruby , C ++ et C # .
- En Python , il est possible d'imbriquer une classe dans une autre classe, méthode ou fonction.
- C ++ a des classes imbriquées qui sont comme les classes membres statiques de Java, sauf qu'elles ne sont pas déclarées avec "static".
- Le langage BETA a introduit cette notion de classes imbriquées.
Code GUI
Les classes internes locales sont souvent utilisées en Java pour définir des rappels pour le code GUI. Les composants peuvent ensuite partager un objet qui implémente une interface de gestion d'événements ou étend une classe d'adaptateur abstraite, contenant le code à exécuter lorsqu'un événement donné est déclenché.
Les classes internes anonymes sont également utilisées lorsque le code de gestion des événements n'est utilisé que par un composant et n'a donc pas besoin d'une référence nommée.
Cela évite une grande actionPerformed(ActionEvent)
méthode monolithique avec plusieurs branches if-else pour identifier la source de l'événement. Ce type de code est souvent considéré comme désordonné et les variations de classe internes sont considérées comme meilleures à tous égards.
Les références
Liens externes
- " Classes internes Alors, à quoi servent les classes internes de toute façon?"
- Classes imbriquées dans D