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 Caravec quatre Wheels. Nos Wheels ont une caractéristique spécifique qui repose sur leur appartenance Car. Cette notion ne représente pas les Wheels en tant que Wheels 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 Carsont composées de quatre instances de la classe Wheel. Cette implémentation particulière de Wheelest 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 Caret le code de Wheelest 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 Wheelclasse 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