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.classDans 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
- Java Language Specification, Java SE 21 — §15.8.2 Class Literals
- Java Language Specification, Java SE 21 — §12.4.1 When Initialization Occurs
- Java Language Specification, Java SE 21 — §12.2 Loading of Classes and Interfaces
- Java Language Specification, Java SE 21 — §8.4.3.6 synchronized Methods
- Class (Java SE 21 & JDK 21)
- Object.getClass() (Java SE 21 & JDK 21)
- Enum.getDeclaringClass() (Java SE 21 & JDK 21)
- EnumMap(Class<K>) (Java SE 21 & JDK 21)
- AtomicIntegerFieldUpdater.newUpdater(Class<U>, String) (Java SE 21 & JDK 21)
- Thread.holdsLock(Object) (Java SE 21 & JDK 21)