WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Klassenliterale in Java: `Typname.class`

Ein `.class`-Literal liefert das Objekt für einen benannten Typ. Damit lassen sich Werte filtern, der Schlüsseltyp einer `EnumMap`, ein Monitor oder ein Feld-Updater festlegen.

Version: Java SE 21

Syntax

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

In Java SE 21 liefert Typname.class das Class-Objekt für den angegebenen Typ. Der Ausdruck erzeugt keine Instanz dieses Typs und löst für sich genommen keine Initialisierung aus. Für einen zugänglichen Referenztyp C hat C.class den Typ Class<C>; das gilt auch für Interfaces und Arrays. int.class und Integer.class haben beide den Typ Class<Integer>, stehen aber für den primitiven Typ bzw. die Wrapperklasse. void.class hat den Typ Class<Void>. In der Kurzschreibweise T.class steht T für einen Typnamen, nicht für eine Typvariable. List<String>.class ist unzulässig; List.class speichert den Elementtyp nicht.

Das Literal wählt den im Code geschriebenen Typ. obj.getClass() liefert dagegen die tatsächliche Laufzeitklasse des Objekts und löst bei einem null-Empfänger eine NullPointerException aus. Type.class hat den Typ Class<Type> und steht für den deklarierten Enum-Typ Type, nicht für eine Konstante. Eine Konstante mit eigenem Klassenrumpf hat eine andere Laufzeitklasse; getDeclaringClass() liefert trotzdem Type.class. new EnumMap<>(Type.class) wählt den Konstruktor für eine leere Map mit Schlüsseln vom Typ Type; für ein Enum namens Status übergibst du Status.class.

In <T> List<T> select(List<?> values, Class<T> type) verknüpft das übergebene Token die Laufzeitprüfung mit dem Elementtyp des Ergebnisses. String.class, Integer.class, StringBuilder.class, TextNote.class und Metric.class wählen jeweils String, Integer, StringBuilder, TextNote bzw. Metric. isInstance akzeptiert kompatible Objekte ungleich null, auch Instanzen von Unterklassen oder Implementierungen eines Interfaces. Danach liefert cast dieselbe Referenz als T; ohne Prüfung führt ein inkompatibler Wert ungleich null zu einer ClassCastException. Filtern macht aus einem StringBuilder keinen String.

synchronized (Main.class) belegt den Monitor des Objekts Class<Main>, den auch eine in Main deklarierte Methode mit static synchronized verwendet. Das ist weder der Monitor von this noch der eines separat erzeugten lock. Gleichnamige Klassen, die von verschiedenen Classloadern definiert werden, können verschiedene Monitore haben. Verwende ein privates Sperrobjekt, wenn fremder Code nicht denselben Monitor belegen können soll.

In AtomicIntegerFieldUpdater.newUpdater(Metric.class, "count") legt das Literal die deklarierende Klasse und den Instanztyp für AtomicIntegerFieldUpdater<Metric> fest. Der Name "count" wählt ein zugängliches Instanzfeld vom Typ volatile int. Fehlt das Feld, ist es unzugänglich oder falsch deklariert, schlägt die Erstellung des Updaters fehl. Zum Erhöhen des Feldwerts übergibst du eine konkrete Metric-Instanz, nicht das Klassen-Token.

Beispiele

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();
    }
}

Ergebnis

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

Die leere Liste `strings` zeigt, dass ein `StringBuilder` nicht zu `String.class` passt. Von den drei geprüften Monitoren hält der Thread nur den Klassenmonitor. Das ist kein Test für Nebenläufigkeit.

Zugehörige Lektionen

  • Java · Lektion 13 · Fortgeschritten · Version: 2
  • Java · Lektion 19 · Fortgeschritten · Version: 2
  • Java · Lektion 27 · Fortgeschritten · Version: 2
  • Java · Lektion 28 · Fortgeschritten · Version: 2
  • Java · Lektion 32 · Fortgeschritten · Version: 2
  • Java · Lektion 10 · Mittlere Stufe · Version: 2
  • Java · Lektion 36 · Mittlere Stufe · Version: 2
  • Java · Lektion 37 · Mittlere Stufe · Version: 2

Quellen