Java Type Casting

Type Casting bezeichnet die Umwandlung eines Wertes von einem Typ in einen anderen. In Java gibt es dafür zwei Varianten: Erweiterungskonvertierungen (Widening), die automatisch stattfinden und keine Informationen verlieren, und Einschränkungskonvertierungen (Narrowing), die einen expliziten Cast erfordern und Daten verlieren können.

Erweiterung (implizite Konvertierung)

Eine Erweiterungskonvertierung überträgt einen Wert in einen größeren Typ. Der Compiler erledigt das automatisch — es ist keine spezielle Syntax erforderlich:

int i = 100;
long l = i;        // int → long (widening)
double d = l;      // long → double (widening)

System.out.println(i);   // 100
System.out.println(l);   // 100
System.out.println(d);   // 100.0

Die standardmäßige Erweiterungsreihenfolge ist:

byte → short → int → long → float → double
              char ↗

(char wird zu int und weiter erweitert, aber nicht zu short oder byte.)

Die Erweiterung verliert nie den Wertebereich — ein long passt immer in den Bereich eines double, auch wenn double nicht jeden long-Wert exakt darstellen kann. Beachten Sie diese Darstellungslücke bei Extremwerten.

Einschränkung (expliziter Cast)

Eine Einschränkungskonvertierung überträgt einen Wert in einen kleineren Typ. Java verweigert dies implizit, da Daten verloren gehen können. Sie müssen es mit (targetType) explizit angeben:

double d = 9.99;
int i = (int) d;   // explicit narrowing cast

System.out.println(i);   // 9 — the fractional part is dropped

Der Cast schneidet in Richtung null ab — er rundet nicht.

Bei ganzen Zahlen behält ein Cast nur die niederwertigen Bits:

int big = 130;
byte b = (byte) big;
System.out.println(b);   // -126 — overflow wraps around

byte hat 8 Bits, Bereich -128…127. Die Bits von 130 (10000010) werden im Zweierkomplement als -126 interpretiert.

Ein häufiger Cast: Ganzzahldivision als reelle Zahl

Reine Ganzzahlarithmetik verwendet die Ganzzahldivision — 5 / 2 == 2, nicht 2.5. Um ein reelles Ergebnis zu erhalten, casten Sie mindestens einen Operanden vor der Division:

int total = 5;
int count = 2;

double avgWrong = total / count;          // 2.0 — division is still integer
double avgRight = (double) total / count; // 2.5 — total widened first

Dies ist der häufigste Grund, einen Cast zu verwenden.

Referenz-Casts

Die (Type)-Syntax funktioniert auch mit Objekten — dort handelt es sich jedoch um eine Laufzeitprüfung, keine Konvertierung. Das Casten einer Referenz bedeutet im Wesentlichen: „Vertrau mir, dieses Objekt ist vom Typ X":

Object o = "Hello";
String s = (String) o;            // OK at runtime
System.out.println(s.length());   // 5

Object n = Integer.valueOf(7);
String bad = (String) n;          // throws ClassCastException at runtime

Um eine Referenz sicher zu casten, prüfen Sie zunächst den Typ mit instanceof:

Object o = "Hello";
if (o instanceof String) {
    String s = (String) o;        // guaranteed safe
    System.out.println(s.length());
}

Pattern matching für instanceof (modernes Java) ermöglicht es, Prüfung und Cast in einem Schritt durchzuführen. Referenz-Casts werden ausführlich in OOP und Polymorphismus behandelt.

Ein vollständiges Beispiel

Wenn der Compiler „hilft" — und wenn nicht

Ein subtiler Fall, den Sie beachten sollten: Arithmetik mit byte, short oder char wird vor der Operation automatisch zu int hochgestuft. Das Ergebnis ist ein int:

byte a = 10;
byte b = 20;
// byte sum = a + b;       // compile error: result is int
byte sum = (byte) (a + b);  // explicit cast needed

Das überrascht jeden beim ersten Mal. Speichern Sie das Ergebnis entweder in int oder casten Sie zurück.

Faustregeln

• Frei erweitern — kein Cast erforderlich, kein Verlust.
• Mit Cast und Prüfung einschränken — stellen Sie sicher, dass der Wert wirklich passt.
• Für die reelle Division ganzer Zahlen casten Sie einen Operanden zu double.
• Für Geldberechnungen verwenden Sie double gar nicht — nutzen Sie BigDecimal, um Rundungsfehler bei binären Gleitkommazahlen zu vermeiden.

Was kommt als Nächstes

Java Operators — die vollständige Übersicht aller Operatoren der Sprache.

Übungen