Casting & Typumwandlung.

Casting ist die Umwandlung eines Wertes von einem Datentyp in einen anderen. Manchmal nötig (z. B. String "42" zu int für Berechnung), manchmal verlustbehaftet (z. B. double 3.7 zu int wird 3, nicht 4). Du lernst hier, wann Java automatisch widened (z. B. int → double), wann ein expliziter Cast nötig ist (Narrowing wie double → int), warum double zu int nur abschneidet (Truncation, nicht rundet), wie String-Parsing mit parseInt/int() funktioniert, warum Java int/int anders rechnet als Python / (Integer-Division), wie Down-Casts bei Objekten mit ClassCastException schiefgehen, und welche Klausur-Stolperer typisch sind (Overflow, deutsche Komma-Notation). Pflichtstoff im 1. Semester.

Die zentralen Konzepte für die Klausur:

• Implizite Konvertierung (Widening): kleinerer Typ wird automatisch zu größerem, z.B. int zu double. Verhindert meist Wertebereichsverlust, kann aber bei Gleitkomma-Zieltypen Präzision verlieren (z. B. int → float, long → double).
• Explizite Konvertierung (Narrowing): größerer Typ zu kleinerem, mit Cast-Syntax (int) 3.7, kann Daten verlieren
• Integer.parseInt(s) / Double.parseDouble(s): String zu Zahl in Java
• String.valueOf(x) / x + "": Zahl zu String in Java
• Python: int(s), str(x), float(s) für Konvertierungen

In Klausuren ist die häufigste Falle: (int) 3.7 ergibt 3 (abgeschnitten), nicht 4 (gerundet). Plus: Integer.parseInt("hallo") wirft NumberFormatException, das musst du oft in einem try-catch behandeln.

Das Problem

Du liest eine Zahl von der Konsole, als String. Du willst damit rechnen.

String s = "42";
int x = s + 8;        // s + 8 ergibt "428" als String;
                      // int x = ... ist Compile-Error,
                      // weil String nicht int ist

s = input()           # liefert immer einen String
x = s + 8             # TypeError: cannot concat str and int

Du musst den Typ ändern, von String zu Zahl. Das nennt man Casting oder Typumwandlung.

Java und Python bieten zwei Casting-Ansätze: automatische Konvertierung (sicher in Richtung größerer Wertebereich, z. B. int → double) und explizite Konvertierung (mit Cast-Operator oder Parse-Funktion bei Verlustrisiko). Schauen wir uns beide an.

Die wichtige Unterscheidung

Regel: Widening ist eine erlaubte Umwandlung in einen Typ mit größerem Wertebereich; bei float/double kann trotzdem Präzision verloren gehen (z. B. int → float oder long → double, weil float nur ~7 und double ~15 signifikante Dezimalstellen hat). Narrowing zu kleineren Typen ist gefährlich (Truncation, Overflow).

Java: explizite Casts

// Auto-Widening (kein Cast nötig)
int i = 5;
double d = i;       // 5.0   automatisch

// Explizit mit Cast-Operator
double pi = 3.14;
int x = (int) pi;   // 3     Truncation, NICHT Rundung!
int y = (int) 3.99; // 3     auch Truncation
int z = (int) -1.5; // -1    Richtung 0, nicht abrunden

Klausur-Falle: (int) 3.99 ist 3, nicht 4. Cast macht Truncation, nicht Round. Für Rundung: Math.round().

Auto-Widening-Reihenfolge

byte → short → int → long → float → double
   ←── kann automatisch ──→
                                ←── braucht expliziten Cast ──

int i = 100;
long l = i;             // OK, automatisch
double d = i;           // OK, automatisch

double d2 = 3.14;
int j = d2;             // FEHLER: braucht (int)
int k = (int) d2;       // OK, explizit

// Achtung: Widening kann trotzdem Präzision verlieren
int big = 16_777_217;   // = 2^24 + 1
float f = big;          // f wird 16_777_216.0f (eine Einheit verloren!)
                        // float-Mantisse hat nur 23 + 1 = 24 effektive Bits

Python: dynamisch mit Funktionen

In Python sind Variablen nicht typgebunden, aber Operationen brauchen passende Typen:

# Konvertierungs-Funktionen
int("42")        # 42
int(3.99)        # 3        (Truncation)
int(-1.5)        # -1
float("3.14")    # 3.14
float(42)        # 42.0
str(42)          # "42"
bool(0)          # False
bool(42)         # True
bool("")         # False     (leerer String)
bool("hallo")    # True

Python truthiness: 0, 0.0, "", [], {}, None sind False. Alles andere ist True.

Auto-Konvertierung in Python

1 + 2.5      # 3.5      int wird automatisch zu float

5 / 2        # 2.5      / liefert IMMER float in Python 3
5 // 2       # 2        // ist Floor-Division (rundet Richtung -∞)
-5 // 2      # -3       Achtung: NICHT wie Java int / (= -2)!

"a" * 3      # "aaa"    str * int erlaubt
"a" + 3      # TypeError: kein Auto-Cast str ↔ int

String ↔ Zahl

Der wichtigste Use-Case. User-Input ist immer String, mit dem man rechnen muss.

String → int

// Java
int x = Integer.parseInt("42");        // 42
int y = Integer.parseInt("3.14");      // NumberFormatException!
int z = Integer.parseInt("abc");       // NumberFormatException!
int w = Integer.parseInt("  42  ");    // NumberFormatException (Whitespace!)

# Python
x = int("42")       # 42
y = int("3.14")     # ValueError!
z = int("abc")      # ValueError!
w = int("  42  ")   # 42  (Python strippt Whitespace)

Klausur: Integer.parseInt akzeptiert KEINEN Whitespace, KEINEN Komma-Punkt-Mix, KEIN "3.14". Nur ganze Zahlen.

String → double

double x = Double.parseDouble("3.14");      // 3.14
double y = Double.parseDouble("3,14");      // FEHLER (Komma!)
double z = Double.parseDouble("1e3");       // 1000.0  (Exponential ok)

x = float("3.14")    # 3.14
y = float("3,14")    # ValueError (Komma!)
z = float("1e3")     # 1000.0

Klausur-Falle: deutsche Komma-Notation funktioniert NICHT. parseDouble braucht Punkt als Dezimal-Trennzeichen.

Zahl → String

String s1 = Integer.toString(42);       // "42"
String s2 = String.valueOf(3.14);       // "3.14"
String s3 = "" + 42;                    // "42"  (häufig, aber nicht best practice)
String s4 = Integer.toString(255, 16);  // "ff"  (Hex)

s1 = str(42)              # "42"
s2 = str(3.14)            # "3.14"
s3 = f"{42}"              # "42"  (f-string)
s4 = format(255, "x")     # "ff"  (Hex)

Integer-Division: der Klausur-Klassiker

Das ist die häufigste Klausur-Falle beim Casting:

Java

int a = 5, b = 2;

int x = a / b;          // 2     (Integer-Division: Truncation)
double y = a / b;       // 2.0   (a/b ist int, dann Auto-Widening)
double z = (double) a / b;  // 2.5   (a wird erst zu double)
double w = a / (double) b;  // 2.5   (b wird zu double)
double v = 5.0 / 2;     // 2.5   (5.0 ist double-Literal)

Regel: bei / mit zwei int-Operanden ist das Ergebnis immer int (Integer-Division). Mindestens ein Operand muss double sein für Float-Ergebnis.

Python 3

a, b = 5, 2

x = a / b          # 2.5   IMMER float (Python 3-Verhalten)
y = a // b         # 2     Floor-Division (entspricht Java's int /)
z = a % b          # 1     Modulo

Python 3: / ist Float-Division, // ist Floor-Division. Ältere Python 2-Tutorials verwirren oft, weil dort / int-Division war.

Floor vs. Truncation

Bei negativen Zahlen unterschiedlich! Java's (int) cast macht Truncation (Richtung 0): (int) -3.9 = -3. Math.floor und Python's // machen Floor (Richtung minus unendlich): Math.floor(-3.9) = -4.0, -7 // 2 = -4. Vermeide das Wort "abrunden", weil es bei negativen Zahlen mehrdeutig ist.

Klausur-Tricks

Trick 1, Cast macht Truncation, kein Round: (int) 3.99 = 3, NICHT 4. Für Round: Math.round().

Trick 2, Integer-Division bei int / int: 5 / 2 in Java = 2. Mindestens ein Operand muss double sein für 2.5.

Trick 3, Zahlen-Literale kennen:

• Java: 5 ist int, 5L ist long, 5.0 ist double, 5f ist float
• Python: 5 ist int, 5.0 ist float (kein Unterschied long/int)

Trick 4, parseInt bei Whitespace/Komma: Java NumberFormatException, Python int() trimmt Whitespace aber kein Komma.

Trick 5, Auto-Widening Reihenfolge (Java):

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

Trick 6, Boolean-Konversion:

• Java: kein Auto-Cast Zahl ↔ boolean. Brauchst x != 0 explizit.
• Python: 0/leer = False, alles andere = True (truthiness)

Trick 7, Floor vs. Truncation bei negativen Zahlen:

• (int) -3.5 = -3 (Truncation, Richtung 0)
• Math.floor(-3.5) = -4 (Floor, Richtung minus unendlich)

Trick 8, Overflow bei Cast:

int big = 300;
byte small = (byte) big;    // -56 (!)

byte hat nur 8 Bit (-128 bis 127). 300 passt nicht → bit-Überschneidung. Kein Compile-Fehler, sondern Bug zur Laufzeit.

Trick 9, Konkatenation vs. Addition (Java):

String s = "Wert: " + 1 + 2;     // "Wert: 12"
String t = "Wert: " + (1 + 2);   // "Wert: 3"

Java wertet von links aus. Erste Konkatenation (String + int) wandelt int zu String, danach wird als String-Operator (Konkatenation) interpretiert.

Trick 10, Vergleich Strings vs. Zahlen:

"5" == 5              // Compile-Fehler in Java

"5" == 5              # False (verschiedene Typen, kein Auto-Cast)
"5" == str(5)         # True

Wo brauchst du Casting?

• User-Input: Konsole liefert immer String, Zahl muss geparsed werden
• JSON / API: Werte aus dem Netz oft als String, müssen konvertiert werden
• Datenbanken: SQL liefert manchmal Strings (vor allem aus Free-Text-Feldern)
• Datei-I/O: fs.readFile liefert String, Zahlen in CSV/TXT brauchen Parse
• Mathematische Operationen: Float-Division statt Integer-Division
• Type-Annotation in TypeScript: as Type ist eine Type Assertion zur Compile-Zeit, keine Laufzeit-Umwandlung. Für echte Konvertierung brauchst du z. B. Number(value), String(value) oder eigenes Parsing.

Faustregel: an jeder Sprach-/System-Grenze (Konsole, Datei, Netzwerk, DB) brauchst du Cast. Innerhalb deines eigenen Codes weniger.

Cast-Lab

Tipp einen Wert ein und sieh sofort wie er in Java und Python in alle relevanten Typen konvertiert wird:

• → int: bei Zahlen Truncation, bei Strings parseInt/int()
• → double: Auto-Widening von int (in Java)
• → String: String.valueOf() / str()
• → boolean: Java erlaubt kein Auto-Cast, Python nutzt truthiness

Bei nicht-parsbaren Strings ("abc") siehst du NumberFormatException in Java und ValueError in Python.

Probier folgendes:

• 3.14 (float) → int → 3 (Truncation Richtung 0)
• "3.14" (String) → int → Exception (NumberFormatException in Java, ValueError in Python). Truncation gilt nur für Zahlen, nicht für Strings.
• "abc" → int → Exception in beiden Sprachen
• "true" → boolean → in Python via bool("true") (immer True für nicht-leere Strings, nicht Inhalts-Parsing!), in Java mit Boolean.parseBoolean("true"). Boolean.parseBoolean ist tolerant: nur ignoriert-case "true" wird true, alles andere false (keine Exception).
• Integer-Division: a=5, b=2 → Java int/int = 2, Python / = 2.5, // = 2. Bei negativen Zahlen unterscheidet sich // (floor) von Java int / (truncation Richtung 0).

Faustregel zum Mitnehmen: Cast double → int macht Truncation, kein Round. Java's int/int ist Integer-Division (5/2 = 2), Python 3's / liefert immer Float (5/2 = 2.5).

---

Code-Stepper: Klausur-Klassiker durchspielen

Drei interaktive Demos zu den häufigsten Klausur-Stolperern beim Casting: Narrowing mit Truncation (Cast double zu int schneidet Nachkommastellen, rundet NICHT), Integer-Overflow bei Cast von long zu int, und ClassCastException beim Down-Cast zwischen Objekt-Typen. Klicke auf Step oder Auto.

1. Narrowing-Cast double zu int: Truncation, kein Round

2. Integer-Overflow: Cast long zu int

Bei Narrowing von long zu int werden die oberen Bits einfach abgeschnitten. Wenn der long-Wert den int-Bereich (±2^31-1, etwa ±2,1 Mrd.) überschreitet, entsteht ein scheinbar zufälliger int-Wert.

3. ClassCastException: falscher Down-Cast

Bei Vererbung speichert eine Variable vom Obertyp ein Subtyp-Objekt (Up-Cast, immer ok). Der Down-Cast zurück zum Subtyp ist nur erlaubt, wenn das Objekt tatsächlich den Ziel-Typ hat. Andernfalls: ClassCastException zur Laufzeit.