Classe interne

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

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

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

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).

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