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

CKTIS / Java

Déclaration d’une classe locale en Java

Une classe locale est une classe imbriquée nommée, déclarée par exemple dans un bloc de méthode. La portée de son nom ne limite pas la durée de vie de ses instances.

Version : Java SE 21

Syntaxe

{
    class LocalName {
        // Fields, constructors, and methods
    }
    LocalName instance = new LocalName();
}

Une déclaration de classe locale telle que class Counter { ... } définit une classe imbriquée nommée directement dans un bloc, par exemple le corps d’une méthode, d’un constructeur ou d’un initialiseur. Elle n’est pas membre de la classe englobante. Contrairement à une classe anonyme, elle a un nom simple et peut être instanciée séparément avec new Counter().

La portée du nom couvre toute la déclaration et le reste du bloc qui la contient directement. Dans un groupe d’instructions d’un bloc switch, elle se termine avec ce groupe. Avant la déclaration ou hors de cette portée, le nom ne désigne pas cette classe. Une instance peut survivre au bloc : on peut la renvoyer sous le type IntSupplier et l’utiliser après la fin de la méthode.

La déclaration d’une classe locale ne peut pas comporter public, protected, private, static, sealed ou non-sealed. Sa superclasse directe et ses superinterfaces directes ne peuvent pas être sealed. Une classe locale ordinaire est une classe interne même dans une méthode static, où elle n’a pas d’instance englobante. En Java SE 21, elle peut néanmoins déclarer ses propres membres static. Les classes locales enum et record sont implicitement static : elles ne sont donc pas des classes internes et ne capturent ni les variables locales ni les paramètres du contexte englobant.

Le code d’instance d’une classe locale ordinaire ne peut capturer des variables locales et des paramètres à sa portée que s’ils sont final ou effectivement finaux. Le compilateur doit aussi pouvoir établir qu’une valeur a été affectée à toute variable locale capturée avant le corps de la classe. Le paramètre step est effectivement final, car il n’est jamais réaffecté. On ne peut pas réaffecter la référence total, mais on peut modifier total[0] : final ne rend pas le tableau immuable.

Exemples

import java.util.function.IntSupplier;

public class LocalClassDemo {
    static IntSupplier makeCounter(int step) {
        final int[] total = {0};

        class Counter implements IntSupplier {
            @Override
            public int getAsInt() {
                total[0] += step;
                return total[0];
            }
        }

        return new Counter();
    }

    public static void main(String[] args) {
        IntSupplier counter = makeCounter(3);
        System.out.println(counter.getAsInt());
        System.out.println(counter.getAsInt());
    }
}

Résultat

3
6

`Counter` capture le paramètre `step` et la référence `total`. Après le retour de `makeCounter(3)`, les appels successifs à `getAsInt()` ajoutent chacun `3` au même élément du tableau. Le programme affiche donc `3`, puis `6`.

Leçons associées

  • Java · Leçon 14 · Avancé · Version : 2
  • Java · Leçon 26 · Avancé · Version : 2
  • Java · Leçon 36 · Avancé · Version : 2
  • Java · Leçon 7 · Intermédiaire · Version : 2

Sources