Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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.class

Em 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