Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Les classes anonymes en Java

Une classe anonyme permet de définir une implémentation d’interface ou une sous-classe et d’en créer une instance dans la même expression.

Version : Java SE 21

Syntaxe

Anonymous implementation: new InterfaceType() { /* member declarations */ }
Anonymous subclass: new BaseType(constructorArguments) { /* member declarations */ }
In a variable declaration, end the declaration with a semicolon after the closing brace.

En Java SE 21, new Interface() { ... } déclare une classe anonyme et en crée une instance. Interface représente le nom d’une interface existante et ... les déclarations dans le corps de la classe. L’objet est une instance de la classe qui implémente l’interface, pas de l’interface elle-même. Chaque évaluation crée un nouvel objet ; chaque occurrence distincte de cette forme déclare une classe différente.

La forme new BaseType(args) { ... } crée une instance d’une sous-classe, à condition que BaseType puisse être étendue et qu’un constructeur approprié soit accessible. Les arguments sont transmis au constructeur de la superclasse. On ne peut pas déclarer explicitement un constructeur pour la classe anonyme, mais son corps peut contenir des champs, des méthodes et des blocs d’initialisation d’instance.

La classe doit implémenter toutes les méthodes abstraites requises. Les implémentations de Action.perform(), Runnable.run() et Executor.execute(Runnable) doivent être public. Utilisez @Override pour que le compilateur détecte une erreur de signature, par exemple une surcharge involontaire au lieu d’une redéfinition.

Dans une méthode d’instance de la classe anonyme, this désigne l’objet anonyme. Une lambda n’introduit pas de this propre et doit avoir une interface fonctionnelle comme type cible. Les deux formes ne peuvent capturer que des variables locales final ou effectivement finales, comme label, à laquelle aucune nouvelle valeur n’est affectée.

new Executor() { public void execute(Runnable r) ... } représente une implémentation anonyme de Executor, et non la création d’un pool de threads. Ici, execute appelle directement r.run() : la tâche s’exécute donc de façon synchrone dans le thread appelant. D’autres implémentations de Executor peuvent utiliser un autre thread ou un pool.

Exemples

import java.util.concurrent.Executor;

public class AnonymousClassDemo {
    interface Action {
        void perform();
    }

    public static void main(String[] args) {
        Action open = new Action() {
            @Override
            public void perform() { System.out.println("Open"); }
        };
        Action close = new Action() {
            @Override
            public void perform() { System.out.println("Close"); }
        };

        Executor direct = new Executor() {
            @Override
            public void execute(Runnable r) {
                r.run();
            }
        };

        String label = "Task ";
        Runnable[] tasks = {
            new Runnable() {
                @Override
                public void run() { System.out.println(label + "1"); }
            },
            new Runnable() {
                @Override
                public void run() { System.out.println(label + "2"); }
            },
            new Runnable() {
                @Override
                public void run() { System.out.println(label + "3"); }
            },
            new Runnable() {
                @Override
                public void run() { System.out.println(label + "4"); }
            }
        };

        open.perform();
        for (Runnable task : tasks) {
            direct.execute(task);
        }
        close.perform();
    }
}

Résultat

Open
Task 1
Task 2
Task 3
Task 4
Close

Deux classes anonymes distinctes implémentent `Action`, et quatre autres implémentent `Runnable`. `Open` s’affiche avant `Task 1` à `Task 4`, et `Close` après ces quatre tâches, car chaque appel à `execute` attend la fin de son appel direct à `run()`.

Leçons associées

  • Java · Leçon 25 · Avancé · Version : 2
  • Java · Leçon 8 · Intermédiaire · Version : 2
  • Java · Leçon 51 · Intermédiaire · Version : 2

Sources