int, double, String, boolean — wie wandelst du sicher um? Auto-Widening, Truncation, parseInt, Integer-Division (5/2 = 2 vs. 2.5). Mit Cast-Lab und Java/Python parallel.
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).
Die zentralen Konzepte für die Klausur:
(int) 3.7, kann Daten verlierenx + "": Zahl zu String in Javaint(s), str(x), float(s) für KonvertierungenIn 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; // FEHLER: "428" oder Compile-Error?
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.
| Implizit (automatisch) | Explizit (mit Cast/Funktion) | |
|---|---|---|
| Java | Auto-Widening: | , |
| Python | Bei numerischen Operationen | , , |
Regel: Konvertierung zu größeren Typen ist meist sicher (kein Datenverlust). Zu kleineren Typen 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.99ist 3, nicht 4. Cast macht Truncation, nicht Round. Für Rundung:Math.round().
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
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,"",[],{},NonesindFalse. Alles andere istTrue.
1 + 2.5 # 3.5 int wird automatisch zu float
5 / 2 # 2.5 / liefert IMMER float in Python 3
5 // 2 # 2 // liefert int (Floor-Division)
"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.
// 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.
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.
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:
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.
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.
| 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).Math.floormacht Floor (immer abrunden, Richtung minus unendlich). Python's//macht Floor.
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:
5 ist int, 5L ist long, 5.0 ist double, 5f ist float5 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:
x != 0 explizit.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 macht alles String, danach Klebezeichen.
Trick 10 — Vergleich Strings vs. Zahlen:
"5" == 5 // Compile-Fehler in Java
"5" == 5 # False (verschiedene Typen, kein Auto-Cast)
"5" == str(5) # True
fs.readFile liefert String, Zahlen in CSV/TXT brauchen Parseas Type ist auch ein CastFaustregel: an jeder Sprach-/System-Grenze (Konsole, Datei, Netzwerk, DB) brauchst du Cast. Innerhalb deines eigenen Codes weniger.
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).
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).
if, else, else if. Wie trifft ein Programm Entscheidungen, und welche Vergleichsoperatoren brauchst du?
for, while, Iteration. Wie wiederhole ich Code, ohne mich zu verzetteln?
Methoden, Parameter, Rückgabewerte. Code, der wiederverwendbar wird.
Die zentralen Konzepte für die Klausur:
(int) 3.7, kann Daten verlierenx + "": Zahl zu String in Javaint(s), str(x), float(s) für KonvertierungenIn 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; // FEHLER: "428" oder Compile-Error?
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.
| 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) |
Regel: Konvertierung zu größeren Typen ist meist sicher (kein Datenverlust). Zu kleineren Typen 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.99ist 3, nicht 4. Cast macht Truncation, nicht Round. Für Rundung:Math.round().
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
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,"",[],{},NonesindFalse. Alles andere istTrue.
1 + 2.5 # 3.5 int wird automatisch zu float
5 / 2 # 2.5 / liefert IMMER float in Python 3
5 // 2 # 2 // liefert int (Floor-Division)
"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.
// 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.
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.
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:
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.
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.
| 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).Math.floormacht Floor (immer abrunden, Richtung minus unendlich). Python's//macht Floor.
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:
5 ist int, 5L ist long, 5.0 ist double, 5f ist float5 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:
x != 0 explizit.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 macht alles String, danach Klebezeichen.
Trick 10 — Vergleich Strings vs. Zahlen:
"5" == 5 // Compile-Fehler in Java
"5" == 5 # False (verschiedene Typen, kein Auto-Cast)
"5" == str(5) # True
fs.readFile liefert String, Zahlen in CSV/TXT brauchen Parseas Type ist auch ein CastFaustregel: 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:
String.valueOf() / str()Bei nicht-parsbaren Strings ("abc") siehst du NumberFormatException in Java und ValueError in Python.
Probier folgendes:
Boolean.parseBooleanInteraktive 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).
Klausurfragen mit Lösungen (8)
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.
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.
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.)
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.
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.
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.
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).
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.
Funktionen, die sich selbst aufrufen. Mit Call-Stack-Visualisierung am Beispiel Fakultät.