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

CKTIS / Java

Littéraux de classe en Java : `NomDuType.class`

Un littéral `.class` donne l’objet qui représente un type nommé. Il sert à filtrer des valeurs, à définir le type des clés d’une `EnumMap`, à choisir un moniteur ou à configurer la mise à jour d’un champ.

Version : Java SE 21

Syntaxe

TypeName { [] } . class
NumericType { [] } . class
boolean { [] } . class
void . class

Braces denote zero or more repetitions; they are not Java tokens in the expression.
Examples: String.class, Runnable.class, String[].class, int[].class, int.class, void.class

Dans Java SE 21, NomDuType.class donne l’objet Class du type indiqué. Cette expression ne crée pas d’instance de ce type et ne déclenche pas à elle seule son initialisation. Pour un type référence accessible C, C.class est de type Class<C> : cela vaut aussi pour les interfaces et les tableaux. int.class et Integer.class ont tous deux le type Class<Integer>, mais représentent respectivement le type primitif et sa classe enveloppe. void.class est de type Class<Void>. Dans la notation T.class, T désigne un nom de type, pas une variable de type. List<String>.class est interdit ; List.class ne conserve pas le type des éléments.

Le littéral sélectionne le type écrit dans le code. À l’inverse, obj.getClass() renvoie la classe réelle de l’objet à l’exécution et lève une NullPointerException si le receveur est null. Type.class est de type Class<Type> et représente l’énumération déclarée Type, pas une constante. Une constante ayant son propre corps de classe a une autre classe à l’exécution, mais getDeclaringClass() renvoie toujours Type.class. new EnumMap<>(Type.class) sélectionne le constructeur d’une map vide dont les clés sont de type Type ; pour une énumération Status, passez Status.class.

Dans <T> List<T> select(List<?> values, Class<T> type), le jeton fourni relie la vérification à l’exécution au type des éléments du résultat. String.class, Integer.class, StringBuilder.class, TextNote.class et Metric.class sélectionnent respectivement String, Integer, StringBuilder, TextNote et Metric. isInstance accepte les objets compatibles non nuls, notamment les instances de sous-classes ou d’implémentations d’interface. Après ce test, cast renvoie la même référence avec le type T ; sans le test, une valeur incompatible non nulle provoque une ClassCastException. Le filtrage ne transforme pas un StringBuilder en String.

synchronized (Main.class) acquiert le moniteur de l’objet Class<Main>, le même qu’utilise une méthode static synchronized déclarée dans Main. Ce n’est ni le moniteur de this ni celui d’un objet lock créé séparément. Des classes de même nom définies par des chargeurs différents peuvent avoir des moniteurs distincts. Utilisez un objet de verrouillage privé si le code extérieur ne doit pas pouvoir acquérir le même moniteur.

Dans AtomicIntegerFieldUpdater.newUpdater(Metric.class, "count"), le littéral indique la classe qui déclare le champ et le type d’instance pour AtomicIntegerFieldUpdater<Metric>. Le nom "count" désigne un champ d’instance accessible de type volatile int. Si le champ est absent, inaccessible ou mal déclaré, la création de l’outil de mise à jour échoue. Pour incrémenter le champ, passez une instance précise de Metric, pas le jeton de classe.

Exemples

import java.util.EnumMap;
import java.util.List;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class Main {
    enum Type { READY {} }
    record TextNote(String text) {}
    static final class Metric {
        volatile int count;
    }

    static <T> List<T> select(List<?> values, Class<T> type) {
        return values.stream().filter(type::isInstance).map(type::cast).toList();
    }

    void demo() {
        Metric metric = new Metric();
        List<?> values = List.of(new TextNote("ready"), metric, 7,
                                 new StringBuilder("not a String"));
        List<TextNote> notes = select(values, TextNote.class);
        List<Metric> metrics = select(values, Metric.class);
        List<Integer> integers = select(values, Integer.class);
        List<String> strings = select(values, String.class);
        System.out.println("note=" + notes.get(0).text());
        System.out.println("metric matches=" + metrics.size());
        System.out.println("integers=" + integers);
        System.out.println("strings=" + strings);

        EnumMap<Type, Integer> counts = new EnumMap<>(Type.class);
        AtomicIntegerFieldUpdater<Metric> updater =
                AtomicIntegerFieldUpdater.newUpdater(Metric.class, "count");
        counts.put(Type.READY, updater.incrementAndGet(metric));
        System.out.println("updated=" + counts.get(Type.READY));
        System.out.println("declaring enum=" + (Type.READY.getDeclaringClass() == Type.class));
        System.out.println("same runtime class=" + Type.class.equals(Type.READY.getClass()));

        Object lock = new Object();
        synchronized (Main.class) {
            System.out.println("class monitor=" + Thread.holdsLock(Main.class));
            System.out.println("instance monitor=" + Thread.holdsLock(this));
            System.out.println("separate monitor=" + Thread.holdsLock(lock));
        }
    }

    public static void main(String[] args) {
        new Main().demo();
    }
}

Résultat

note=ready
metric matches=1
integers=[7]
strings=[]
updated=1
declaring enum=true
same runtime class=false
class monitor=true
instance monitor=false
separate monitor=false

La liste vide `strings` montre qu’un `StringBuilder` ne correspond pas à `String.class`. Parmi les trois moniteurs vérifiés, seul celui de la classe est détenu par le thread. Ce n’est pas un test de concurrence.

Leçons associées

  • Java · Leçon 13 · Avancé · Version : 2
  • Java · Leçon 19 · Avancé · Version : 2
  • Java · Leçon 27 · Avancé · Version : 2
  • Java · Leçon 28 · Avancé · Version : 2
  • Java · Leçon 32 · Avancé · Version : 2
  • Java · Leçon 10 · Intermédiaire · Version : 2
  • Java · Leçon 36 · Intermédiaire · Version : 2
  • Java · Leçon 37 · Intermédiaire · Version : 2

Sources