CKTIS / Java
Literais de classe em Java: `NomeDoTipo.class`
Um literal `.class` fornece o objeto que representa um tipo. Permite filtrar valores, definir o tipo das chaves de um `EnumMap`, escolher um monitor ou configurar a atualização de um campo.
Versão: Java SE 21
Sintaxe
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.classEm Java SE 21, NomeDoTipo.class devolve o objeto Class do tipo indicado. Não cria uma instância desse tipo nem desencadeia, por si só, a sua inicialização. Para um tipo de referência acessível C, C.class tem o tipo Class<C>; isto inclui interfaces e arrays. int.class e Integer.class têm ambos o tipo Class<Integer>, mas representam, respetivamente, o tipo primitivo e a classe encapsuladora. void.class tem o tipo Class<Void>. Na notação T.class, T representa um nome de tipo, não uma variável de tipo. List<String>.class é inválido; List.class não conserva o tipo dos elementos.
O literal seleciona o tipo escrito no código. Já obj.getClass() devolve a classe efetiva do objeto em tempo de execução e lança NullPointerException se o recetor for null. Type.class tem o tipo Class<Type> e representa o enum declarado Type, não uma constante. Uma constante com corpo de classe próprio tem uma classe diferente em tempo de execução, mas getDeclaringClass() continua a devolver Type.class. new EnumMap<>(Type.class) seleciona o construtor de um mapa vazio com chaves do tipo Type; para um enum chamado Status, passa Status.class.
Em <T> List<T> select(List<?> values, Class<T> type), o token passado associa a verificação em tempo de execução ao tipo dos elementos do resultado. String.class, Integer.class, StringBuilder.class, TextNote.class e Metric.class selecionam, respetivamente, String, Integer, StringBuilder, TextNote e Metric. isInstance aceita objetos compatíveis diferentes de null, incluindo instâncias de subclasses ou de implementações de interfaces. Após a verificação, cast devolve a mesma referência com o tipo T; sem a verificação, um valor incompatível diferente de null causa ClassCastException. O filtro não transforma um StringBuilder numa String.
synchronized (Main.class) adquire o monitor do objeto Class<Main>, o mesmo que um método static synchronized declarado em Main usa. Não é o monitor de this nem o de um objeto lock criado em separado. Classes com o mesmo nome definidas por carregadores diferentes podem ter monitores distintos. Usa um objeto de bloqueio privado se o código externo não deve poder adquirir o mesmo monitor.
Em AtomicIntegerFieldUpdater.newUpdater(Metric.class, "count"), o literal identifica a classe que declara o campo e o tipo de instância para AtomicIntegerFieldUpdater<Metric>. O nome "count" seleciona um campo de instância acessível de tipo volatile int. Se o campo não existir, não for acessível ou estiver mal declarado, a criação do atualizador falha. Para incrementar o campo é necessária uma instância concreta de Metric, não o token de classe.
Exemplos
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();
}
}Resultado
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
A lista vazia `strings` mostra que um `StringBuilder` não corresponde a `String.class`. Dos três monitores verificados, a thread detém apenas o monitor da classe. Não é um teste de concorrência.
Lições relacionadas
- Java · Lição 13 · Avançado · Versão: 2
- Java · Lição 19 · Avançado · Versão: 2
- Java · Lição 27 · Avançado · Versão: 2
- Java · Lição 28 · Avançado · Versão: 2
- Java · Lição 32 · Avançado · Versão: 2
- Java · Lição 10 · Intermédio · Versão: 2
- Java · Lição 36 · Intermédio · Versão: 2
- Java · Lição 37 · Intermédio · Versão: 2
Fontes
- 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)