Programmiergrundlagen3Lerneinheiten33minStand18.06.2026

Casting & Typumwandlung.

Fachliche Qualität

S-Tier · GoldstandardZuletzt geprüft am 18.05.2026

Diese Lerneinheit wurde für typische Bachelor-Klausuren konzipiert. So prüfen wir · Fehler entdeckt? Melde ihn uns oder markiere die fragliche Stelle direkt im Text oben.

Klausur-ÜbersichtKomplette Übersicht: alle Tabs als linearer Text zum Lernen

Alle Tabs der Lerneinheit (Erklärung · Interaktiv · Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).

Teil 1·Erklärung

Erklärung

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, (z. B. int → double), (Narrowing wie double → int), warum double zu int (Truncation, nicht rundet), wie mit / funktioniert, warum Java anders rechnet als Python (Integer-Division), wie mit schiefgehen, und welche typisch sind (Overflow, deutsche Komma-Notation). Pflichtstoff im 1. Semester.

Zur KategorieProgrammiergrundlagen.Mehr Themen entdeckenZum Themen-Hub.

Casting & Typumwandlung, Programmiergrundlagen · UniProMax

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.

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.

	Implizit (automatisch)	Explizit (mit Cast/Funktion)
Java	Auto-Widening: $\text{int} \to \text{double}$	$(\text{int}) 3.14$ , $\text{Integer.parseInt}(s)$
Python	Bei numerischen Operationen	$\text{int}(s)$ , $\text{str}(x)$ , $\text{float}(s)$

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).

// 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

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

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)

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

Wert	Floor (Math.floor)	Truncation (Cast (int))
3.9	3	3
3.1	3	3
-3.1	-4	-3
-3.9	-4	-3

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.

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

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.

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).

Lade Visualisierung...

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).

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

Lade Visualisierung...

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.

Lade Visualisierung...

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.

Lade Visualisierung...

Anmelden, um den Fortschritt zu speichern.

Nächster Schritt

Wenn du fertig bist: jetzt üben.

Aktives Abrufen festigt Wissen schneller als nochmal lesen.

parseInt

int()

int/int

/

ClassCastException

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

// 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

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

# 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

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

Wert	Floor (Math.floor)	Truncation (Cast (int))
3.9	3	3
3.1	3	3
-3.1	-4	-3
-3.9	-4	-3

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.

Teil 2·Visualisierung / Interaktiv

Interaktiv

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).

Interaktive Visualisierung

Type-Casting zwischen int, double, String mit Verlust- und Präzisions-Anzeige.

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

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

Interaktive Visualisierung

Interaktive Komponente: probiere sie im Topic-Player oben aus.

2. Integer-Overflow: Cast long zu int

Interaktive Visualisierung

Interaktive Komponente: probiere sie im Topic-Player oben aus.

3. ClassCastException: falscher Down-Cast

Interaktive Visualisierung

Interaktive Komponente: probiere sie im Topic-Player oben aus.

Teil 3·Quiz / Klausurfragen

Quiz

Klausurfragen mit Lösungen (8)

F1.Was gibt (int) 3.99 in Java zurück?

Antwort: 3 (Truncation)

Erklärung: Cast double → int macht Truncation: Nachkommastellen werden ABGESCHNITTEN, NICHT gerundet. (int) 3.99 = 3, (int) 3.5 = 3. Für korrektes Runden: Math.round(3.99) = 4.

F2.Java: was ist 5 / 2?

Antwort: 2

Erklärung: Beide Operanden sind int → Integer-Division → Ergebnis ist int (Truncation). 5 / 2 = 2. Für 2.5 müsste mindestens ein Operand double sein: 5.0 / 2 oder (double) 5 / 2.

F3.Python 3: was ist 5 / 2?

Antwort: 2.5

Erklärung: Python 3: / ist IMMER Float-Division, auch bei zwei int-Operanden. 5 / 2 = 2.5. Für Integer-Verhalten in Python: 5 // 2 (Floor-Division) = 2. (In Python 2 war / int-Division, verwirrt oft Anfänger.)

F4.Java: was passiert bei Integer.parseInt("3.14")?

Antwort: NumberFormatException

Erklärung: parseInt akzeptiert NUR ganze Zahlen. '3.14' enthält einen Punkt → NumberFormatException zur Laufzeit. Für Float-Werte: Double.parseDouble. Vorher prüfen oder mit try/catch absichern.

F5.Welche Konvertierung passiert in Java automatisch (ohne expliziten Cast)?

Antwort: int → double

Erklärung: Auto-Widening: kleinere Typen werden ohne Cast in größere konvertiert. Reihenfolge: byte → short → int → long → float → double. Andersrum (von größer zu kleiner) braucht expliziten Cast wegen möglichen Datenverlust.

F6.Python: was ist bool("") und bool("hallo")?

Antwort: False, True

Erklärung: Python truthiness: leerer String '' = False, jeder nicht-leere String = True (auch 'False' als String!). Genauso: 0 = False, alle anderen Zahlen = True. None = False. Klausurfalle: bool('False') ist True, weil String nicht leer.

F7.Java: String s = "Wert: " + 1 + 2;, was steht in s?

Antwort: "Wert: 12"

Erklärung: Java wertet von links aus. "Wert: " + 1 wird zu "Wert: 1" (Konkatenation, weil String beteiligt). Dann "Wert: 1" + 2 wird zu "Wert: 12". Klausur-Klassiker. Für "Wert: 3" muss man klammern: "Wert: " + (1 + 2).

F8.Was passiert bei (byte) 300 in Java?

Antwort: Liefert -56 (Bit-Overflow)

Erklärung: byte hat 8 Bit (-128 bis 127). 300 passt nicht. Cast schneidet die oberen Bits ab → 300 mod 256 (mit Vorzeichen) = -56. KEIN Compile-Fehler, sondern Bug zur Laufzeit. Vorsicht bei Casts in kleinere Typen.

	Implizit (automatisch)	Explizit (mit Cast/Funktion)
Java	Auto-Widening: `int → double`	`(int) 3.14`, `Integer.parseInt(s)`
Python	Bei numerischen Operationen	`int(s)`, `str(x)`, `float(s)`

Erklärung

Erklärung

Das Problem

Die wichtige Unterscheidung

Java: explizite Casts

Auto-Widening-Reihenfolge

Python: dynamisch mit Funktionen

Auto-Konvertierung in Python

String ↔ Zahl

String → int

String → double

Zahl → String

Integer-Division: der Klausur-Klassiker

Java

Python 3

Floor vs. Truncation

Klausur-Tricks

Wo brauchst du Casting?

Cast-Lab

Code-Stepper: Klausur-Klassiker durchspielen

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

2. Integer-Overflow: Cast long zu int

3. ClassCastException: falscher Down-Cast

Wenn du fertig bist: jetzt üben.

Das Problem

Die wichtige Unterscheidung

Java: explizite Casts

Auto-Widening-Reihenfolge

Python: dynamisch mit Funktionen

Auto-Konvertierung in Python

String ↔ Zahl

String → int

String → double

Zahl → String

Integer-Division: der Klausur-Klassiker

Java

Python 3

Floor vs. Truncation

Klausur-Tricks

Wo brauchst du Casting?

Interaktiv

Cast-Lab

Code-Stepper: Klausur-Klassiker durchspielen

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

2. Integer-Overflow: Cast long zu int

3. ClassCastException: falscher Down-Cast

Quiz