Java Academy · Lektion

Ganzzahlarithmetik und Überlauf

Verstehen Sie Ganzzahldivision, Modulo, das Überlaufverhalten und wie Sie Überläufe erkennen.

Ganzzahlarithmetik und Überlauf 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.

Ganzzahlarithmetik & Überlauf

Java-Ganzzahlen haben eine feste Größe. Wenn eine Berechnung den maximalen oder minimalen Wert überschreitet, läuft sie stillschweigend über – es wird keine Exception ausgelöst. Dieses Verhalten zu verstehen, hilft, schwer erkennbare Fehler zu vermeiden.

Bereiche von Ganzzahlen

Jeder Ganzzahltyp hat abhängig von seiner Bitbreite einen begrenzten Wertebereich:

byte: -128 bis 127
short: -32.768 bis 32.767
int: -2.147.483.648 bis 2.147.483.647
long: -9,2 × 10^18 bis 9,2 × 10^18

System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648
System.out.println(Long.MAX_VALUE);    // 9223372036854775807
System.out.println(Byte.MAX_VALUE);    // 127

Überlauf: Stilles Zurückspringen

Das Addieren von 1 zu Integer.MAX_VALUE führt zu Integer.MIN_VALUE. Dies ist eine Zweierkomplement-Arithmetik – Java garantiert kein anderes Verhalten und löst keine Exception aus.

int max = Integer.MAX_VALUE;
System.out.println(max + 1); // -2147483648 (overflow!)

byte b = 127;
b++;  // wraps to -128
System.out.println(b); // -128

// Real bug: counting votes in a large election with int
int votes = Integer.MAX_VALUE;
votes += 100; // silently wrong
System.out.println(votes); // negative number!

Überlauf mit Math.addExact erkennen

Java 8+ führte Math.addExact(), multiplyExact() und subtractExact() ein. Diese Methoden lösen bei einem Überlauf eine ArithmeticException aus, anstatt stillschweigend überzulaufen.

try {
    int result = Math.addExact(Integer.MAX_VALUE, 1);
} catch (ArithmeticException e) {
    System.out.println("Overflow detected!"); // prints this
}

try {
    long safe = Math.multiplyExact(100_000L, 100_000L);
    System.out.println(safe); // 10000000000
} catch (ArithmeticException e) {
    System.out.println("Multiply overflow");
}

Ganzzahldivision und Modulo

Bei der Ganzzahldivision wird in Richtung null abgeschnitten. Der Operator % liefert den Rest mit dem Vorzeichen des Dividenden. Achten Sie auf Division durch null – sie löst eine ArithmeticException aus.

System.out.println(10 / 3);    // 3 (not 3.33)
System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1 (sign follows dividend)
System.out.println(-10 % -3);  // -1

try {
    int x = 5 / 0; // ArithmeticException: / by zero
} catch (ArithmeticException e) {
    System.out.println(e.getMessage()); // / by zero
}

// Float division by zero gives Infinity, not exception
System.out.println(5.0 / 0); // Infinity

Long-Arithmetik für große Zahlen

Verwenden Sie long, wenn Werte den int-Bereich überschreiten können. Schreiben Sie an Ganzzahlliterale vom Typ long immer L, damit es vor der Zuweisung nicht zu einem Überlauf kommt.

// Bug: multiplication done as int, then widened
long wrong = 1_000_000 * 1_000_000;   // overflows int!
System.out.println(wrong); // -727379968 (wrong!)

// Fix: one operand is long
long correct = 1_000_000L * 1_000_000L;
System.out.println(correct); // 1000000000000

// Or cast first
long alsOk = (long) 1_000_000 * 1_000_000;
System.out.println(alsOk); // 1000000000000

Bitverschiebungsoperatoren

Bitverschiebungsoperatoren bieten eine schnelle Möglichkeit, mit Zweierpotenzen zu multiplizieren oder zu dividieren:

n << k – Verschiebung nach links: Multiplikation mit 2^k
n >> k – vorzeichenbehaftete Verschiebung nach rechts: Division durch 2^k
n >>> k – vorzeichenlose Verschiebung nach rechts: Auffüllen mit Nullen

int n = 8;
System.out.println(n << 1);  // 16 (8 * 2)
System.out.println(n << 2);  // 32 (8 * 4)
System.out.println(n >> 1);  // 4  (8 / 2)
System.out.println(n >> 2);  // 2  (8 / 4)

// Check if number is power of 2
boolean isPow2 = n > 0 && (n & (n - 1)) == 0;
System.out.println(isPow2); // true

Bitweises AND, OR und XOR

Bitweise Operatoren arbeiten auf einzelnen Bits und werden für Berechtigungen, Flags und Protokolle auf niedriger Ebene verwendet.

int a = 0b1010; // 10
int b = 0b1100; // 12

System.out.println(Integer.toBinaryString(a & b)); // 1000 (AND = 8)
System.out.println(Integer.toBinaryString(a | b)); // 1110 (OR  = 14)
System.out.println(Integer.toBinaryString(a ^ b)); // 0110 (XOR = 6)
System.out.println(Integer.toBinaryString(~a));    // ...11110101 (NOT)

// Permission flags example
int READ  = 0b001;
int WRITE = 0b010;
int EXEC  = 0b100;
int perms = READ | WRITE; // user has read+write
System.out.println((perms & EXEC) != 0); // false — no exec

Unterstriche in numerischen Literalen

Java 7+ erlaubt Unterstriche in numerischen Literalen, um die Lesbarkeit zu verbessern. Der Compiler ignoriert sie.

int million = 1_000_000;
long creditCard = 4_111_1111_1111_1111L;
double pi = 3.141_592_653_589_793;
int hex = 0xFF_EC_D1_2E;
int binary = 0b0001_0101_0110;

System.out.println(million);   // 1000000
System.out.println(creditCard); // 4111111111111111

BigInteger für beliebige Genauigkeit

Wenn Werte den Bereich von long überschreiten, verwenden Sie BigInteger. Dieser Typ hat keinen Überlauf, ist aber langsamer als primitive Datentypen. Verwenden Sie ihn für kryptografische Schlüssel, Fakultäten und astronomisch große Zahlen.

import java.math.BigInteger;

BigInteger factorial100 = BigInteger.ONE;
for (int i = 2; i <= 100; i++) {
    factorial100 = factorial100.multiply(BigInteger.valueOf(i));
}
System.out.println(factorial100.toString().length() + " digits"); // 158 digits

BigInteger a = new BigInteger("999999999999999999999999999999");
BigInteger b = new BigInteger("1");
System.out.println(a.add(b)); // 1000000000000000000000000000000

Praktisch: Überlaufsicherer Zähler

Ein Muster zur Implementierung eines Zählers, der Überläufe sicher behandelt, indem Math.addExact verwendet und bei einem Überlauf auf Long.MAX_VALUE zurückgegriffen wird.

class SafeCounter {
    private long count = 0;

    public void increment() {
        try {
            count = Math.addExact(count, 1L);
        } catch (ArithmeticException e) {
            count = Long.MAX_VALUE; // cap at max
        }
    }

    public long get() { return count; }
}

SafeCounter sc = new SafeCounter();
sc.increment();
sc.increment();
System.out.println(sc.get()); // 2

Schnelltest

Welchen Wert hat der folgende Ausdruck?

long result = 1_000_000 * 1_000_000;
System.out.println(result);

Zusammenfassung: Ganzzahlarithmetik und Überlauf

Wichtigste Erkenntnisse:

Ein Ganzzahlüberlauf läuft stillschweigend um – standardmäßig wird keine Ausnahme ausgelöst
Verwenden Sie Math.addExact/multiplyExact/subtractExact, um Überläufe zu erkennen
Die Ganzzahldivision schneidet in Richtung null ab; das Vorzeichen von % folgt dem Dividenden
Verwenden Sie long-Literale (Suffix L), wenn Zwischenergebnisse den Wertebereich von int überschreiten könnten
BigInteger verarbeitet beliebig große Werte ohne Überlauf
Bitshift-Operatoren sind schnelle Alternativen zur Multiplikation und Division mit Zweierpotenzen

Häufig gestellte Fragen

Ist die Lektion „Ganzzahlarithmetik und Überlauf“ kostenlos?

Ja — der vollständige Text von „Ganzzahlarithmetik und Überlauf“ 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 „Ganzzahlarithmetik und Überlauf“?

Verstehen Sie Ganzzahldivision, Modulo, das Überlaufverhalten und wie Sie Überläufe erkennen. 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 „Ganzzahlarithmetik und Überlauf“?

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

← Zurück zu Java Academy