Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Literales de clase en Java: `NombreDelTipo.class`

Un literal `.class` da acceso al objeto que representa un tipo. Sirve para filtrar valores, fijar el tipo de clave de un `EnumMap`, elegir un monitor o configurar un actualizador de campos.

Versión: Java SE 21

Sintaxis

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

En Java SE 21, NombreDelTipo.class produce el objeto Class del tipo indicado. La expresión no crea una instancia de ese tipo ni provoca por sí sola su inicialización. Para un tipo de referencia accesible C, C.class tiene el tipo Class<C>; esto incluye interfaces y arrays. int.class e Integer.class tienen el tipo Class<Integer>, pero representan el tipo primitivo y la clase envoltorio, respectivamente. void.class tiene el tipo Class<Void>. En la notación T.class, T es un nombre de tipo, no una variable de tipo. List<String>.class no es válido; List.class no conserva el tipo de los elementos.

El literal selecciona el tipo escrito en el código. En cambio, obj.getClass() devuelve la clase real del objeto en tiempo de ejecución y lanza NullPointerException si el receptor es null. Type.class tiene el tipo Class<Type> y representa el enum declarado Type, no una constante. Una constante con su propio cuerpo de clase tiene otra clase en tiempo de ejecución, pero getDeclaringClass() sigue devolviendo Type.class. new EnumMap<>(Type.class) selecciona el constructor de un mapa vacío con claves de tipo Type; para un enum llamado Status, pasa Status.class.

En <T> List<T> select(List<?> values, Class<T> type), el token proporcionado vincula la comprobación en ejecución con el tipo de los elementos del resultado. String.class, Integer.class, StringBuilder.class, TextNote.class y Metric.class seleccionan String, Integer, StringBuilder, TextNote y Metric, respectivamente. isInstance acepta objetos compatibles no nulos, como instancias de subclases o de implementaciones de interfaces. Tras la comprobación, cast devuelve la misma referencia con tipo T; sin ella, un valor incompatible no nulo provoca ClassCastException. El filtro no convierte un StringBuilder en un String.

synchronized (Main.class) adquiere el monitor del objeto Class<Main>, el mismo que usa un método static synchronized declarado en Main. No es el monitor de this ni el de un lock creado por separado. Las clases del mismo nombre definidas por cargadores distintos pueden tener monitores diferentes. Usa un objeto de bloqueo privado si el código externo no debe poder adquirir el mismo monitor.

En AtomicIntegerFieldUpdater.newUpdater(Metric.class, "count"), el literal identifica la clase que declara el campo y el tipo de instancia para AtomicIntegerFieldUpdater<Metric>. El nombre "count" selecciona un campo de instancia accesible de tipo volatile int. Si el campo no existe, no es accesible o está mal declarado, falla la creación del actualizador. Para incrementar el campo se pasa una instancia concreta de Metric, no el token de clase.

Ejemplos

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

La lista vacía `strings` muestra que un `StringBuilder` no coincide con `String.class`. De los tres monitores comprobados, el hilo solo posee el de la clase. No es una prueba de concurrencia.

Lecciones relacionadas

  • Java · Lección 13 · Avanzado · Versión: 2
  • Java · Lección 19 · Avanzado · Versión: 2
  • Java · Lección 27 · Avanzado · Versión: 2
  • Java · Lección 28 · Avanzado · Versión: 2
  • Java · Lección 32 · Avanzado · Versión: 2
  • Java · Lección 10 · Intermedio · Versión: 2
  • Java · Lección 36 · Intermedio · Versión: 2
  • Java · Lección 37 · Intermedio · Versión: 2

Fuentes