Java Arithmetische Operatoren

Java verfügt über fünf arithmetische Operatoren: Addition, Subtraktion, Multiplikation, Division und Rest. Ihre Syntax ist dieselbe wie in C, JavaScript oder Python – aber Javas statische Typisierung birgt einige Überraschungen rund um Division und Überlauf, die du kennen solltest, bevor du die erste Berechnung schreibst.

Diese Seite behandelt alle fünf Operatoren, warum Integer-Division abschneidet, wie sich % bei negativen Zahlen verhält, die Operatorrangfolge, die ++/---Kurzformen, stillen Integer-Überlauf und die Gleitkomma-Präzisionsfalle. Für alle Java-Operatoren im Überblick, siehe Java Operators.

Die fünf Operatoren

int a = 14;
int b = 4;

System.out.println(a + b);  // 18
System.out.println(a - b);  // 10
System.out.println(a * b);  // 56
System.out.println(a / b);  // 3   — integer division
System.out.println(a % b);  // 2   — remainder

Integer-Division schneidet ab

Wenn beide Operanden von / Integer sind, ist das Ergebnis ein Integer und der Nachkommateil wird abgeschnitten (Richtung null trunciert):

System.out.println(7 / 2);    // 3, not 3.5
System.out.println(-7 / 2);   // -3
System.out.println(1 / 3);    // 0

Um ein Ergebnis als reelle Zahl zu erhalten, muss mindestens ein Operand ein Gleitkommatyp sein. Du kannst ein Literal als double schreiben (7.0) oder einen int zu double casten:

System.out.println(7.0 / 2);        // 3.5
System.out.println(7 / 2.0);        // 3.5
System.out.println((double) 7 / 2); // 3.5

Der Cast bindet stärker als /, daher castet (double) 7 / 2 zuerst 7 und dividiert dann – das ergibt 3.5. Vorsicht bei (double) (7 / 2): Die Integer-Division findet zuerst statt und du erhältst 3.0.

Das ist eine häufige Fehlerquelle für Anfänger. Wenn du 0 siehst, wo du einen von null verschiedenen Quotienten erwartet hast, liegt es wahrscheinlich an Integer-Division.

Der Rest-Operator %

% gibt den Rest der Integer-Division zurück. Er ist so definiert, dass (a / b) * b + (a % b) == a gilt:

System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1  — sign matches the dividend
System.out.println(10 % -3);   // 1

Häufige Anwendungen:

• Teilbarkeit prüfen: if (n % 2 == 0) prüft auf gerade Zahlen.
• Zyklisches Indizieren: arr[(i + 1) % arr.length] springt nach dem letzten Element wieder zu 0.
• Ziffern oder Einheiten extrahieren: n % 10 ist die letzte Ziffer; seconds % 60 sind die Sekunden innerhalb einer Minute.

Für weitere numerische Hilfsfunktionen – Potenzen, Runden, Quadratwurzeln – siehe Java Math Class.

% funktioniert auch mit double, wobei er den IEEE 754-Rest zurückgibt – nützlich, aber die Methode Math.IEEEremainder bietet genauere Kontrolle.

Operatorrangfolge

Es gelten die Standardregeln:

1. *, /, % zuerst
2. dann +, -
3. von links nach rechts bei gleicher Priorität

int result = 2 + 3 * 4;      // 14, not 20
int result2 = (2 + 3) * 4;   // 20
int result3 = 10 - 2 - 3;    // 5  — left-to-right

Im Zweifel Klammern setzen. Das kostet nichts.

Inkrement und Dekrement – ++ und --

Die unären Operatoren ++ und -- erhöhen bzw. verringern eine Variable um 1:

int x = 5;
x++;     // x is 6
x--;     // x is 5

Sie gibt es in Präfix-Form (++x) und Postfix-Form (x++). Der Unterschied spielt nur innerhalb eines Ausdrucks eine Rolle:

int a = 5;
int b = a++;   // postfix: b is 5 (old value), a becomes 6
int c = ++a;   // prefix: a becomes 7, c is 7

Für bessere Lesbarkeit solltest du ++ und -- möglichst auf einer eigenen Zeile verwenden.

Überlauf wickelt sich stillschweigend um

Integer-Arithmetik mit int und long läuft bei Überlauf um – es wird keine Ausnahme geworfen:

int max = Integer.MAX_VALUE;    // 2147483647
int wrapped = max + 1;          // -2147483648 (Integer.MIN_VALUE)

Wenn du Überlauferkennung benötigst, verwende Math.addExact, Math.multiplyExact usw., die bei Überlauf eine ArithmeticException werfen.

Gleitkomma-Besonderheiten

double ist IEEE 754 – schnell und gut unterstützt, aber es kann die meisten Dezimalbrüche nicht exakt darstellen:

System.out.println(0.1 + 0.2);   // 0.30000000000000004

Das ist kein Java-Fehler – so funktioniert binäre Gleitkomma-Arithmetik. Für Geldbeträge, wissenschaftliche Präzision oder überall dort, wo du exakte Dezimalarithmetik benötigst, verwende BigDecimal:

import java.math.BigDecimal;

BigDecimal sum = new BigDecimal("0.1").add(new BigDecimal("0.2"));
System.out.println(sum);   // 0.3

(Übergib new BigDecimal(...) immer einen String; new BigDecimal(0.1) würde die binäre Ungenauigkeit übernehmen.)

Eine Demonstration

Was kommt als Nächstes

Java Assignment Operators — =, += und die Familie der zusammengesetzten Zuweisungsoperatoren.

Übungen