CKTIS / Java
Letterali di classe in Java: `NomeTipo.class`
Un letterale `.class` fornisce l’oggetto che rappresenta un tipo. Puoi usarlo per filtrare valori, specificare le chiavi di una `EnumMap`, scegliere un monitor o configurare l’aggiornamento di un campo.
Versione: Java SE 21
Sintassi
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.classIn Java SE 21, NomeTipo.class restituisce l’oggetto Class del tipo indicato. Non crea un’istanza di quel tipo né ne provoca da solo l’inizializzazione. Per un tipo riferimento accessibile C, C.class ha tipo Class<C>; questo vale anche per interfacce e array. int.class e Integer.class hanno entrambi tipo Class<Integer>, ma rappresentano rispettivamente il tipo primitivo e la classe wrapper. void.class ha tipo Class<Void>. Nella notazione T.class, T indica un nome di tipo, non una variabile di tipo. List<String>.class non è ammesso; List.class non conserva il tipo degli elementi.
Il letterale seleziona il tipo scritto nel codice. obj.getClass() restituisce invece la classe effettiva dell’oggetto a runtime e lancia NullPointerException se il ricevente è null. Type.class ha tipo Class<Type> e rappresenta l’enum dichiarato Type, non una costante. Una costante con un proprio corpo di classe ha una classe a runtime diversa, ma getDeclaringClass() restituisce comunque Type.class. new EnumMap<>(Type.class) seleziona il costruttore di una mappa vuota con chiavi di tipo Type; per un enum chiamato Status, passa Status.class.
In <T> List<T> select(List<?> values, Class<T> type), il token passato collega il controllo a runtime al tipo degli elementi del risultato. String.class, Integer.class, StringBuilder.class, TextNote.class e Metric.class selezionano rispettivamente String, Integer, StringBuilder, TextNote e Metric. isInstance accetta oggetti compatibili non nulli, comprese le istanze di sottoclassi e di classi che implementano l’interfaccia. Dopo il controllo, cast restituisce lo stesso riferimento con tipo T; senza il controllo, un valore incompatibile non nullo causa ClassCastException. Il filtro non trasforma uno StringBuilder in una String.
synchronized (Main.class) acquisisce il monitor dell’oggetto Class<Main>, lo stesso usato da un metodo static synchronized dichiarato in Main. Non è il monitor di this né quello di un lock creato separatamente. Classi con lo stesso nome definite da class loader diversi possono avere monitor diversi. Usa un oggetto di blocco privato se il codice esterno non deve poter acquisire lo stesso monitor.
In AtomicIntegerFieldUpdater.newUpdater(Metric.class, "count"), il letterale identifica la classe che dichiara il campo e il tipo di istanza per AtomicIntegerFieldUpdater<Metric>. Il nome "count" seleziona un campo di istanza accessibile di tipo volatile int. Se il campo manca, non è accessibile o è dichiarato in modo errato, la creazione dell’updater fallisce. Per incrementare il campo serve un’istanza concreta di Metric, non il token di classe.
Esempi
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();
}
}Risultato
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 lista vuota `strings` mostra che uno `StringBuilder` non corrisponde a `String.class`. Tra i tre monitor controllati, il thread detiene solo quello della classe. Non è un test di concorrenza.
Lezioni correlate
- Java · Lezione 13 · Avanzato · Versione: 2
- Java · Lezione 19 · Avanzato · Versione: 2
- Java · Lezione 27 · Avanzato · Versione: 2
- Java · Lezione 28 · Avanzato · Versione: 2
- Java · Lezione 32 · Avanzato · Versione: 2
- Java · Lezione 10 · Intermedio · Versione: 2
- Java · Lezione 36 · Intermedio · Versione: 2
- Java · Lezione 37 · Intermedio · Versione: 2
Fonti
- 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)