0Pricing
Java Academy · Lektion

Verbreiterungs- und Verengungskonvertierungen

Lernen Sie automatische Verbreiterungskonvertierungen kennen und erfahren Sie, wie Sie explizite Verengungs-Casts sicher durchführen.

Verbreiterungs- und Verengungskonvertierungen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Typkonvertierungen in Java

Java ermöglicht die Konvertierung von Werten zwischen kompatiblen Typen. Es gibt zwei Richtungen:

  • Widening – Konvertierung in einen größeren Typ (sicher, automatisch)
  • Narrowing – Konvertierung in einen kleineren Typ (riskant, erfordert einen expliziten Cast)

Widening-Konvertierung

Widening erfolgt automatisch, wenn Sie einen Wert einem größeren kompatiblen Typ zuweisen. Dabei gehen keine Daten verloren, da der Zieltyp alle Werte des Quelltyps darstellen kann.

Reihenfolge des Widening: byte → short → int → long → float → double

byte b = 42;
short s = b;    // byte → short (widening)
int i = s;      // short → int (widening)
long l = i;     // int → long (widening)
float f = l;    // long → float (widening)
double d = f;   // float → double (widening)

System.out.println(d); // 42.0

Narrowing-Konvertierung

Narrowing muss explizit mit dem Cast-Operator (type) durchgeführt werden. Der Wert kann abgeschnitten oder verfälscht werden, wenn er nicht in den Zieltyp passt.

double price = 99.99;
int wholePart = (int) price; // narrows — decimal truncated
System.out.println(wholePart); // 99 (not rounded!)

long bigNum = 130L;
byte small = (byte) bigNum;  // 130 overflows byte (max 127)
System.out.println(small);   // -126 (unexpected!)

Überlauf beim Narrowing

Wenn beim Narrowing ein Überlauf auftritt, wickelt Java den Wert mithilfe modularer Arithmetik um – es wird keine Exception ausgelöst. Sie müssen dies selbst verhindern.

int million = 1_000_000;
byte narrowed = (byte) million;
System.out.println(narrowed); // 64 (wraps around)

// Safe narrowing: check bounds first
if (million >= Byte.MIN_VALUE && million <= Byte.MAX_VALUE) {
    byte safe = (byte) million;
} else {
    System.out.println("Value doesn't fit in byte!");
}

Konvertierungen zwischen char und int

char ist eine vorzeichenlose 16-Bit-Ganzzahl, die einen Unicode-Codepunkt darstellt. Der Typ wird automatisch zu int erweitert, muss aber für die Rückkonvertierung von int zu char explizit gecastet werden.

char letter = 'A';
int code = letter;          // widening: char → int
System.out.println(code);   // 65

int nextCode = code + 1;
char nextLetter = (char) nextCode; // narrowing: int → char
System.out.println(nextLetter);    // B

// Useful for Caesar cipher shifts
char shifted = (char) ('a' + 3);
System.out.println(shifted); // d

Abschneiden von Gleitkommazahlen zu Ganzzahlen

Das Casten einer Gleitkommazahl zu einer Ganzzahl schneidet in Richtung null ab – es rundet nicht. Verwenden Sie Math.round(), wenn Sie runden müssen.

double pos = 3.9;
double neg = -3.9;

System.out.println((int) pos);         // 3 (not 4)
System.out.println((int) neg);         // -3 (not -4)
System.out.println(Math.round(pos));   // 4
System.out.println(Math.round(neg));   // -4

String-zu-Zahl-Konvertierungen

Zum Parsen eines String in eine Zahl verwenden Sie Wrapper-Methoden – kein Casting. Die Übergabe eines nicht numerischen Strings löst NumberFormatException aus.

String input = "42";
int parsed = Integer.parseInt(input);
double parsedD = Double.parseDouble("3.14");

System.out.println(parsed + 1);  // 43
System.out.println(parsedD);     // 3.14

try {
    int bad = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("Not a valid number!");
}

Konvertieren von Zahlen in Strings

Eine Zahl lässt sich mit String.valueOf(), Integer.toString() oder durch String-Verkettung mit "" in einen String konvertieren.

int score = 95;
String s1 = String.valueOf(score);    // "95"
String s2 = Integer.toString(score);  // "95"
String s3 = score + "";              // "95" (concat trick)

System.out.println(s1.getClass().getSimpleName()); // String

// Converting to different bases
System.out.println(Integer.toBinaryString(42)); // 101010
System.out.println(Integer.toHexString(255));   // ff

Typ-Promotion in Ausdrücken

In arithmetischen Ausdrücken stuft Java Operanden automatisch hoch:

  • byte, short, char → werden vor der Operation zu int hochgestuft
  • Ist einer der Operanden long, ist das Ergebnis long
  • Ist einer der Operanden float oder double, entspricht das Ergebnis dem weiter gefassten Typ
byte x = 10;
byte y = 20;
// byte z = x + y; // compile error! sum is promoted to int
int z = x + y;      // correct

long a = 100L;
float b = 2.5f;
double result = a * b; // long * float → double
System.out.println(result); // 250.0

Operatoren für zusammengesetzte Zuweisungen

Zusammengesetzte Operatoren wie +=, -= und *= enthalten einen impliziten Narrowing-Cast. Dadurch können Sie mit byte- und short-Variablen kompakten Code schreiben.

byte count = 100;
// count = count + 1; // compile error — int result needs cast
count += 1;           // OK — compound op casts automatically
System.out.println(count); // 101

short total = 1000;
total *= 2;  // implicit narrow cast included
System.out.println(total); // 2000

Praxis: Sicheres Parsen von Ganzzahlen

Ein praxisnahes Muster: Benutzereingaben sicher parsen, den Wertebereich validieren und anschließend auf den genau benötigten Typ verengen.

public static byte parseAsByte(String input) {
    int value = Integer.parseInt(input); // can throw NumberFormatException
    if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
        throw new IllegalArgumentException(
            "Value " + value + " out of byte range");
    }
    return (byte) value;
}

// Usage
System.out.println(parseAsByte("100")); // 100
System.out.println(parseAsByte("200")); // IllegalArgumentException

Schnelltest

Welche Ausgabe erzeugt der folgende Code?

double d = -7.8;
int i = (int) d;
System.out.println(i);

Zusammenfassung: Verbreiterung und Verengung

Die wichtigsten Erkenntnisse:

  • Eine Verbreiterung erfolgt automatisch und sicher: byte→short→int→long→float→double
  • Für eine Verengung ist ein expliziter Cast erforderlich; dabei können Daten verloren gehen oder Überläufe auftreten
  • char wird zu int verbreitert; int kann mit einem Cast wieder zu char verengt werden
  • Die Konvertierung von Gleitkommazahlen zu int schneidet in Richtung null ab (keine Rundung)
  • Verwenden Sie Integer.parseInt/Double.parseDouble, um Strings in Zahlen zu konvertieren
  • Zusammengesetzte Operatoren (+=, *=) enthalten implizite Verengungs-Casts

Häufig gestellte Fragen

Ist die Lektion „Verbreiterungs- und Verengungskonvertierungen“ kostenlos?

Ja — der vollständige Text von „Verbreiterungs- und Verengungskonvertierungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Verbreiterungs- und Verengungskonvertierungen“?

Lernen Sie automatische Verbreiterungskonvertierungen kennen und erfahren Sie, wie Sie explizite Verengungs-Casts sicher durchführen. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Verbreiterungs- und Verengungskonvertierungen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Primitive Datentypen vs. Referenztypen
  2. Verbreiterungs- und Verengungskonvertierungen
  3. Der instanceof-Operator
  4. Typ-Casting in der Praxis
← Zurück zu Java Academy