Java Academy · Leçon

Classes locales et anonymes

Déclarez des classes dans des méthodes et créez à la volée des implémentations anonymes d’interfaces.

Classes locales et anonymes est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Classes locales et anonymes

Les classes locales sont définies à l’intérieur d’une méthode. Les classes anonymes sont des classes locales sans nom : elles combinent la déclaration et l’instanciation de la classe. Toutes deux capturent les variables locales effectivement finales.

Déclaration d’une classe locale

Une classe locale est déclarée à l’intérieur du corps d’une méthode. Elle peut accéder aux membres de la classe englobante et aux variables locales effectivement finales.

static void greet(String language) {
    // Local class — defined inside the method
    class Greeter {
        String sayHello(String name) {
            // Can access 'language' — it is effectively final
            return switch (language) {
                case "EN" -> "Hello, " + name;
                case "ES" -> "Hola, " + name;
                case "FR" -> "Bonjour, " + name;
                default   -> "Hi, " + name;
            };
        }
    }

    Greeter g = new Greeter();
    System.out.println(g.sayHello("Alice"));
}
greet("ES"); // Hola, Alice

Variables effectivement finales

Les classes locales et anonymes ne peuvent capturer que des variables locales qui sont effectivement finales : elles ne sont jamais réaffectées après leur initialisation.

void process(int threshold) {
    // threshold is effectively final (never reassigned)
    Runnable r = new Runnable() {
        public void run() {
            System.out.println("Threshold: " + threshold);
        }
    };
    r.run();

    // threshold = 10; // If you add this, the anonymous class won't compile
}

Principes des classes anonymes

Une classe anonyme implémente une interface ou étend une classe directement, en une seule expression.

interface Comparator<T> {
    int compare(T a, T b);
}

// Anonymous class implementing Comparator
java.util.Comparator<String> byLength = new java.util.Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return Integer.compare(a.length(), b.length());
    }
};

List<String> words = new ArrayList<>(List.of("banana", "fig", "apple", "kiwi"));
words.sort(byLength);
System.out.println(words); // [fig, kiwi, apple, banana]

Classe anonyme ou lambda

Pour les interfaces à méthode abstraite unique (SAM), les lambdas remplacent les classes anonymes. Les classes anonymes restent nécessaires pour les interfaces comportant plusieurs méthodes ou lorsqu’il faut étendre des classes abstraites.

// Anonymous class for single-method interface
Runnable r1 = new Runnable() {
    public void run() { System.out.println("Running!"); }
};

// Lambda — cleaner for SAM interfaces
Runnable r2 = () -> System.out.println("Running!");

// Must use anonymous class for multi-method interface:
java.io.FilenameFilter filter = new java.io.FilenameFilter() {
    public boolean accept(java.io.File dir, String name) {
        return name.endsWith(".java");
    }
}; // FilenameFilter is not a SAM — no lambda shorthand

Classe anonyme avec état

Les classes anonymes peuvent posséder des champs, contrairement aux lambdas. Cette possibilité est utile lorsque vous devez conserver un état dans l’implémentation anonyme.

interface Counter { int increment(); int get(); }

Counter counter = new Counter() {
    private int count = 0;

    public int increment() { return ++count; }
    public int get()       { return count; }
};

System.out.println(counter.increment()); // 1
System.out.println(counter.increment()); // 2
System.out.println(counter.get());       // 2

Modèle de l’écouteur anonyme

Avant l’apparition des lambdas, les classes anonymes constituaient le modèle standard pour les écouteurs d’événements dans la programmation d’interfaces graphiques (GUI) et Android.

// Modern Android/Swing style: anonymous class listener
Button loginButton = new Button(); // hypothetical
loginButton.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick() {
        System.out.println("Login button clicked!");
    }
});

// Modern equivalent with lambda (if OnClickListener is SAM):
loginButton.setOnClickListener(() -> System.out.println("Clicked!"));

Classe locale pour une logique complexe

Les classes locales conviennent lorsque vous avez besoin d’une classe comportant plusieurs méthodes à un seul endroit : la logique est trop complexe pour une lambda, mais trop spécifique pour une classe de niveau supérieur.

static List<String> processData(List<String> data, String prefix) {
    // Local class: complex enough for a class, used only here
    class DataProcessor {
        List<String> result = new ArrayList<>();

        void process(String item) {
            // prefix is effectively final
            if (item.startsWith(prefix)) {
                result.add(item.toUpperCase());
            }
        }
    }
    DataProcessor dp = new DataProcessor();
    data.forEach(dp::process);
    return dp.result;
}
System.out.println(processData(List.of("apple","avocado","banana"), "a"));
// [APPLE, AVOCADO]

Classe anonyme pour une classe abstraite

Les classes anonymes peuvent étendre des classes abstraites et redéfinir leurs méthodes abstraites sans créer de sous-classe nommée.

abstract class ReportFormatter {
    abstract String formatHeader(String title);
    abstract String formatBody(List<String> rows);

    String format(String title, List<String> rows) {
        return formatHeader(title) + "\n" + formatBody(rows);
    }
}

ReportFormatter csvFormatter = new ReportFormatter() {
    public String formatHeader(String t) { return "\"" + t + "\""; }
    public String formatBody(List<String> rows) {
        return String.join("\n", rows);
    }
};
System.out.println(csvFormatter.format("Sales", List.of("a,1","b,2")));

Anti-modèle de l’initialisation à double accolade

L’astuce de l’initialisation à double accolade utilise des classes anonymes pour initialiser des collections. Elle crée une sous-classe avec un initialiseur d’instance. Évitez-la : elle est inefficace et source d’erreurs.

// Anti-pattern: double-brace initialization
Map<String, Integer> map = new HashMap<String, Integer>() {{
    put("a", 1);
    put("b", 2);
}};
// Creates an anonymous HashMap subclass — wasteful!

// GOOD: use Map.of() or Map.ofEntries()
Map<String, Integer> better = Map.of("a", 1, "b", 2);

// Or a mutable map:
Map<String, Integer> mutable = new HashMap<>(Map.of("a", 1, "b", 2));

Choisir entre lambda, classe anonyme et classe locale

Guide de décision :

Lambda : une seule méthode abstraite, aucun état supplémentaire, pas d’héritage
Classe anonyme : plusieurs méthodes, besoin d’un état ou extension d’une classe abstraite
Classe locale : besoin de réutilisation dans la méthode, plusieurs méthodes ou état complexe

Vérification rapide

Que fait toujours une classe anonyme dans une seule expression ?

Récapitulatif : classes locales et anonymes

Points essentiels :

Les classes locales sont définies dans des méthodes et peuvent accéder aux variables locales effectivement finales
Les classes anonymes combinent la déclaration et l’instanciation de la classe dans une seule expression
Les classes anonymes peuvent posséder des champs et plusieurs méthodes, contrairement aux lambdas
Les lambdas remplacent les classes anonymes pour les interfaces à méthode abstraite unique
Utilisez des classes locales lorsque la logique est assez complexe pour nécessiter une classe, mais reste spécifique à une seule méthode
Évitez l’initialisation à double accolade : elle crée des sous-classes anonymes inutiles

Questions Fréquemment Posées

La leçon « Classes locales et anonymes » est-elle gratuite ?

Oui — le texte complet de « Classes locales et anonymes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Classes locales et anonymes » ?

Déclarez des classes dans des méthodes et créez à la volée des implémentations anonymes d’interfaces. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Classes locales et anonymes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Classes imbriquées statiques
Classes internes et accès à la classe externe
Classes locales et anonymes
Choisir la bonne stratégie d’imbrication

← Retour à Java Academy