Classes internes

██████████25 % Traduction --- Inner class → Classe interne --- (+)

•  Statut de la traduction : En cours
•  Commentaire : Y rajouter des exemples de code dans différents langages permettraient de mieux montrer l'intérêt des classes internes
•  Demandeur : Windu.2b (d) 12 février 2009 à 16:02 (CET)
•  Intérêt de la traduction : L'article intéressant et je préfèrerais le lire et le consulter en français.

---

•  Traducteur(s) : Windu.2b (d)
  •  Avancement de la traduction : ██████████25 %
•  Version traduite : 12 février 2009
•  Liens utiles : Comment participer à la traduction ? ; Outils de traduction ; Traduire les liens internes

Page de suivi de traduction   ---   Mettre à jour ces informations (instructions)

 

En programmation orientée objet (POO), une classe interne (de l'anglais nested class ou inner class) est une classe déclarée au sein d'une autre classe ou d'une interface.
On les retrouve dans des langages comme Java, depuis la version 1.1, ou D. En Python, il est possible de créer une classe interne au sein d'une classe, méthode ou fonction.

Généralités

Les types de classes internes

En Java, il existe plusieurs types de classes internes.

Les classes statiques

Déclarées avec le mot-clé static, elles fonctionnent comme les classes statiques habituelles, elles ne sont pas rattachées à une instance et ne peuvent accéder qu'aux variables et méthodes statiques de la classe englobante. Les types extérieurs doivent par contre d'abord préfixer le nom de la la classe interne par celui de la classe englobante. Les interfaces internes sont implicitement statiques.

/**
 * Classe englobante
 */
public class ClasseEnglobante
{
	private static String	variableStatique	= "variable statique";
 
 
 
 
	/**
	 * Constructeur de la classe englobante
	 */
	public ClasseEnglobante()
	{
	}
 
 
 
 
	/**
	 * Méthode statique pouvant invoquer la classe interne statique
	 */
	public static void staticMethod()
	{
		InterfaceInterne ic = new ClasseInterne();
		ic.affiche();
	}
 
 
 
	/**
	 * Classe interne statique
	 */
	private static class ClasseInterne implements InterfaceInterne
	{
		/**
		 * Constructeur de la classe interne statique
		 */
		public ClasseInterne()
		{
		}
 
 
 
 
		/**
		 * Implémentation de l'interface interne
		 * Invocation de la variable statique de la classe englobante
		 */
		public void affiche()
		{
			System.out.println( variableStatique );
		}
	}
 
	/**
	 * Interface interne (implicitement statique)
	 */
	private interface InterfaceInterne
	{
		public void affiche();
	}
}

Les classes internes

Chaque instance d'une classe interne se réfère à une instance de la classe englobante, sauf pour les classes internes locales et les classes anonymes déclarées dans un contexte statique. Par conséquent, elles peuvent implicitement se référer aux variables et méthodes d'instance de la classe englobante. La référence vers l'instance de la classe englobante peut être obtenue via NomDeLaClasseEnglobante.this. En revanche, une classe interne ne peut pas contenir de variables ou méthodes statiques.À sa création, elle doit avoir une référence vers la classe englobante, ce qui signifie qu'elle ne peut être instanciée que dans une méthode d'instance ou un constructeur de la classe englobante, ou (pour les classes membres et les classes anonymes) en utilisant la syntaxe instanceEnglobante.new ClasseInterne()

Les classe membres

Elles sont déclarées en dehors de toutes fonctions et ne sont pas déclarées statiques.

Les classes locales

Elles sont déclarées au sein d'une méthode et ne peuvent se référer qu'au corps de ladite méthode. Elles peuvent utiliser les variables et paramètres locaux de la méthode, mais seulement s'ils sont déclarés final (car l'instance de la classe locale doit contient en fait une copie des variables, et donc afin d'éviter d'avoir 2 variables modifiables avec le même nom et la même portée, il ne faut pas qu'elles soient modifiables).

Les classes anonymes

Ce sont en fait des classes locales directement déclarées et instanciées au sein d'une même expression de code. Elles peuvent directement étendre une classe ou implémenter une interface. Elles peuvent spécifier les arguments d'un des constructeurs de la super-classe mais ne peuvent pas en définir.

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
 
/**
 * Classe englobante
 */
public class ClasseEnglobante
{
	/**
	 * Méthode englobant l'appel à une classe anonyme
	 */
	public void methodeEnglobante()
	{
		/**
		 * Déclaration et instanciation de la classe anonyme pour un bouton
		 * Le bouton est déclaré 'final' afin que la classe anonyme puisse y accéder
		 */
		final JButton bouton = new JButton( "monBouton" );
		bouton.addActionListener( new ActionListener()
		{
			public void actionPerformed( ActionEvent e )
			{
				System.out.println( bouton.toString() );
			}
		} );
	}
}

Interfaces graphiques

Les classes internes locales sont souvent utilisées en Java pour définir les callbacks des interfaces graphiques. Les composants peuvent ainsi partager un objet qui implémente une interface de gestion d'évènement ou une classe adapter, contenant le code à exécuter quand ledit évènement est reçu.%%% Les classes anonymes sont aussi utilisées quand le code de gestion d'évènement n'est utilisé que par un composant et ne nécessite pas, par conséquent, une référence vers une classe nommée.

• (en) Cet article est partiellement ou en totalité issu d’une traduction de l’article de Wikipédia en anglais intitulé « Inner class ».