Une classe imbriquée est une classe définie à l'intérieur d'une autre classe. Java en a quatre types — imbriquée statique, interne (non-statique), locale et anonyme — chacune ayant un accès différent à la classe englobante et des cas d'usage différents.
public class Outer {
private static int data = 10;
static class Nested { // static → no reference to an Outer INSTANCE
void show() {
System.out.println(data); // can access static members of Outer only
}
}
}
Outer.Nested n = new Outer.Nested(); // created without an Outer instance
Une classe imbriquée static se comporte comme une classe de haut niveau mais est namespaced à l'intérieur de l'extérieure. Elle ne conserve pas une référence à une instance extérieure — utilisée pour grouper des assistants (par ex. un Builder, Node dans une structure de données).
public class Outer {
private int value = 5;
class Inner { // non-static → has an implicit reference to Outer
void show() {
System.out.println(value); // can access Outer's INSTANCE members (even private)
}
}
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // needs an Outer instance to create
Une classe interne non-statique conserve une référence implicite à son instance englobante, donc elle peut accéder aux champs d'instance de l'objet externe. (Attention : cette référence peut causer des fuites mémoire si l'instance interne survit à l'externe.)
void process() {
class Helper { // local to this method
void run() { ... }
}
new Helper().run();
}
Rarement utilisée ; scopée à la méthode.
// implement an interface/abstract class inline, for single use
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) { handleClick(); }
});
Runnable task = new Runnable() {
public void run() { System.out.println("running"); }
};
Une classe anonyme est une implémentation unique d'une interface ou d'une classe, définie et instanciée en une seule fois — historiquement courante pour les gestionnaires d'événements et les callbacks. Le Java moderne remplace souvent ces classes par des lambdas quand la cible est une interface fonctionnelle :
button.addActionListener(e -> handleClick()); // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
Les classes imbriquées sont un outil utile pour grouper logiquement les classes qui ne sont utilisées que dans un contexte, augmentant l'encapsulation et la lisibilité.
Comprendre les types — en particulier la distinction statique-vs-interne (statique = indépendante, interne = conserve une référence à l'instance englobante) — importe pour la conception et pour éviter les bogues : la référence extérieure implicite des classes internes peut causer des fuites mémoire, et choisir statique quand vous n'avez pas besoin de l'instance externe est le comportement par défaut plus propre.
Les classes anonymes étaient la façon classique de fournir des implémentations en ligne (gestionnaires d'événements, comparateurs), et savoir qu'elles sont largement remplacées par les lambdas pour les interfaces fonctionnelles reflète la maîtrise du Java moderne.
Elles apparaissent partout dans la bibliothèque standard (par ex. Map.Entry est une interface imbriquée, les builders sont des classes imbriquées statiques), ce qui en fait une connaissance pratique et fréquemment rencontrée.