Classe interne

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

En programmation orientée objet, 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[modifier | modifier le code]

Types de classes internes[modifier | modifier le code]

En Java, il existe plusieurs types de classes internes.

Classes statiques (Java)[modifier | modifier le code]

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 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();
	}
}

Classes internes[modifier | modifier le code]

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 interne 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()

Classe membres[modifier | modifier le code]

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

Classes locales[modifier | modifier le code]

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 conserver une copie distincte 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).

Classes anonymes[modifier | modifier le code]

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[modifier | modifier le code]

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.