Formations — 1 037 leçons en français

Accueil › Java › Classes internes, anonymes et locales

Classes internes, anonymes et locales

Aller plus loin en objetdebutant

Java permet de déclarer une classe à l'intérieur d'une autre classe ou d'une méthode. Quatre formes existent, avec une différence essentielle : une classe interne d'instance garde une référence cachée vers l'objet englobant, une classe interne statique non.

public class Commande {
    private final List<LigneCommande> lignes = new ArrayList<>();

    // classe interne statique : pas de lien avec une instance de Commande
    public static class LigneCommande {
        private final String produit;
        private final int quantite;

        public LigneCommande(String produit, int quantite) {
            this.produit = produit;
            this.quantite = quantite;
        }
    }

    // classe interne d'instance : peut accéder à "lignes" directement
    public class RecapitulatifDetaille {
        public int nombreArticles() {
            return lignes.size(); // accède implicitement à Commande.this.lignes
        }
    }
}

Une classe locale est déclarée dans une méthode, une classe anonyme est déclarée et instanciée en une seule expression, sans nom :

Comparator<LigneCommande> parQuantite = new Comparator<>() { // classe anonyme
    @Override
    public int compare(LigneCommande a, LigneCommande b) {
        return Integer.compare(a.quantite, b.quantite);
    }
};

Quand l'interface n'a qu'une seule méthode abstraite (interface fonctionnelle), une lambda remplace avantageusement la classe anonyme — sujet détaillé au niveau intermédiaire, dans le chapitre sur la programmation fonctionnelle.

Les termes à connaître

Classe interne statique (imbriquée)

Classe déclarée static à l'intérieur d'une autre. Elle ne porte aucune référence vers une instance de la classe englobante : elle se comporte comme une classe de premier niveau, simplement rangée dans l'espace de noms de l'autre classe.

Classe interne d'instance

Classe déclarée sans static à l'intérieur d'une autre. Chaque instance porte une référence implicite vers l'instance englobante qui l'a créée (Externe.this), ce qui la lie à son cycle de vie et peut provoquer une fuite mémoire si elle survit trop longtemps.

Classe locale

Classe déclarée à l'intérieur d'un corps de méthode. Visible uniquement dans cette méthode, elle peut capturer les variables locales effectivement finales de la méthode englobante.

Classe anonyme

Classe sans nom, déclarée et instanciée en une seule expression, généralement pour fournir une implémentation ponctuelle d'une interface ou d'une classe abstraite. Souvent remplaçable par une lambda quand l'interface n'a qu'une seule méthode abstraite.

Variable effectivement finale

Variable locale jamais réassignée après son initialisation, même sans le mot-clé final. C'est la condition requise pour qu'une classe locale ou anonyme (ou une lambda) puisse la capturer.

Fuite mémoire par référence implicite

Situation où une classe interne d'instance (ou une classe anonyme non statique) reste référencée plus longtemps que prévu, et empêche ainsi le ramasse-miettes de libérer l'instance englobante à laquelle elle est implicitement rattachée.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.