Typumwandlung in Java: Erweiterung, Einschränkung und Konvertierungen

Was Typumwandlung bedeutet

Java ist statisch typisiert: Jeder Wert hat einen Typ, und der Compiler lässt dich inkompatible Typen nicht stillschweigend vermischen. Die Typumwandlung ist die Art und Weise, wie du einen Wert von einem Typ in einen anderen konvertierst — manchmal macht Java es für dich, und manchmal musst du es explizit verlangen.

Es gibt zwei Richtungen. Von einem kleineren Typ zu einem größeren zu wechseln (ein int in ein double) ist sicher und geschieht automatisch. Von einem größeren Typ zu einem kleineren zu wechseln (ein double in ein int) kann Daten verlieren, daher zwingt dich Java, es mit einem Cast auszuschreiben.

Erweiterung: die automatische Konvertierung

Eine erweiternde Konvertierung verschiebt einen Wert in einen Typ mit mehr Platz. Es kann nichts verloren gehen, daher macht Java es für dich ohne Cast:

public class Main {
    public static void main(String[] args) {
        int count = 7;
        double price = count;   // int -> double, automatisch

        System.out.println(price);   // 7.0
    }
}

Die int-7 passt in ein double und wird zu 7.0. Die Erweiterungsreihenfolge für Zahlen ist byte -> short -> int -> long -> float -> double; eine Zuweisung von links nach rechts entlang dieser Kette benötigt nie einen Cast. Deshalb „funktioniert" das Mischen von Typen in der Arithmetik oft einfach — Java erweitert zuerst den kleineren Operanden.

Einschränkung: der explizite Cast

In die andere Richtung — eine einschränkende Konvertierung — können Daten verloren gehen, daher verweigert der Compiler dies, es sei denn, du setzt den Zieltyp in Klammern vor den Wert:

public class Main {
    public static void main(String[] args) {
        double pi = 3.9;
        int whole = (int) pi;   // expliziter einschränkender Cast

        System.out.println(whole);   // 3, nicht 4
    }
}

(int) pi ist der Cast. Achte darauf, was er macht: Er schneidet in Richtung Null ab und verwirft einfach den Nachkommateil. 3.9 wird zu 3, und -3.9 wird zu -3. Er rundet nicht. Wenn du runden möchtest, ist das ein anderes Werkzeug:

public class Main {
    public static void main(String[] args) {
        double value = 3.9;

        System.out.println((int) value);          // 3  (schneidet ab)
        System.out.println(Math.round(value));    // 4  (rundet)
    }
}

Zu vergessen, dass ein Cast abschneidet, ist einer der häufigsten Anfängerfehler — wenn deine „gerundete" Zahl immer um eins zu niedrig ist, liegt es meist daran.

Die Falle der Ganzzahldivision

In diese Falle tappt jeder einmal. Wenn beide Operanden int sind, führt der Operator / eine Ganzzahldivision durch und verwirft den Rest — bevor überhaupt eine Zuweisung an ein double erfolgt:

public class Main {
    public static void main(String[] args) {
        int a = 7;
        int b = 2;

        double wrong = a / b;          // 3.0  - die Division wird zuerst als int gerechnet!
        double right = (double) a / b; // 3.5  - zuerst einen Operanden casten

        System.out.println(wrong);
        System.out.println(right);
    }
}

a / b ist 7 / 2, vollständig in int-Arithmetik berechnet, was 3 ergibt. Die anschließende Erweiterung zu double macht aus 3 nur 3.0 — die .5 ist bereits weg. Wenn man zuerst einen Operanden zu double castet ((double) a / b), zwingt das den gesamten Ausdruck in Gleitkomma und liefert das gewünschte 3.5. Du musst nur eine Seite casten; Java erweitert die andere passend dazu.

Wenn die Einschränkung überläuft

Ein Cast prüft nicht, ob der Wert hineinpasst. Wenn nicht, werden die Bits einfach abgeschnitten und du bekommst ein überraschendes Ergebnis — kein Fehler, keine Warnung:

public class Main {
    public static void main(String[] args) {
        int big = 300;
        byte small = (byte) big;   // byte fasst nur -128..127

        System.out.println(small);   // 44, nicht 300
    }
}

300 passt nicht in ein byte, daher werden die höherwertigen Bits verworfen und du erhältst 44. Das ist „stiller" Datenverlust — das Programm läuft einwandfrei und liefert ein falsches Ergebnis. Schränke nur ein, wenn du sicher bist, dass der Wert in den kleineren Typ passt.

Konvertieren zwischen Zahlen und Strings

Ein String ist ein Objekt, keine Zahl, daher kannst du ihn nicht mit (int) casten — das ist ein Kompilierungsfehler. Für die Konvertierung gibt es stattdessen eigene Methoden:

public class Main {
    public static void main(String[] args) {
        String text = "42";
        int n = Integer.parseInt(text);       // String -> int
        double d = Double.parseDouble("3.14"); // String -> double

        System.out.println(n + 1);   // 43

        String back = String.valueOf(n);       // int -> String
        System.out.println(back + "!");         // 42!
    }
}

Von Text zu einer Zahl verwendet man Integer.parseInt / Double.parseDouble. Ist der String keine gültige Zahl (etwa "hello"), werfen diese Methoden eine NumberFormatException. Von einer Zahl zu Text verwendest du String.valueOf(n) oder verkettest einfach mit "" — denn n + "" zwingt das int in einen String. Achte auf den Unterschied zwischen "5" + 1 (was den String "51" ergibt) und 5 + 1 (was 6 ergibt); das + bedeutet Verkettung, sobald ein String beteiligt ist.

Objekte casten

Casting gilt auch für Objektreferenzen, nicht nur für primitive Typen. Du kannst eine Referenz entlang einer Vererbungskette in einen verwandten Typ casten — die Erweiterung zu einem übergeordneten Typ ist automatisch, das Einschränken zurück nach unten benötigt einen expliziten Cast und ist nur sicher, wenn das Objekt wirklich von diesem Typ ist:

Object o = "hello";
String s = (String) o;        // OK: o verweist tatsächlich auf einen String
Integer bad = (Integer) o;    // kompiliert, wirft aber zur Laufzeit eine ClassCastException

Der zweite Cast kompiliert, fliegt aber zur Laufzeit mit einer ClassCastException auf, weil das Objekt ein String ist, kein Integer. Das wirst du richtig kennenlernen, sobald du zu Vererbung und Polymorphie kommst; für den Moment reicht es zu wissen, dass die (Type)-Syntax dieselbe Idee ist, angewendet auf Objekte.

Als Nächstes: if-else

Casting erlaubt dir, Werte umzuformen; der nächste Schritt ist, dein Programm anhand dieser Werte zwischen Pfaden wählen zu lassen. Die if-else-Anweisung führt einen Block aus, wenn eine Bedingung wahr ist, und einen anderen, wenn sie falsch ist — die Grundlage jeder Entscheidung, die dein Code trifft. Das ist die nächste Seite.