Arithmetic Operators

Kurz: Operatoren für Rechenoperationen: + (Addition), - (Subtraktion), * (Multiplikation), / (Division) und % (Modulo/Rest).

Genauer: Bei / mit zwei int-Operanden wird ganzzahlig dividiert, der Nachkommateil fällt weg (7 / 2 ergibt 3, nicht 3.5) — für eine echte Division muss mindestens ein Operand ein double/float sein. % liefert den Rest einer Division, häufig genutzt um z. B. gerade/ungerade Zahlen zu prüfen (n % 2 == 0).

Im Detail

Die Integer-Division ist eine der häufigsten Fehlerquellen für Java-Einsteiger, weil sie sich lautlos “falsch” verhält, ohne einen Fehler oder eine Warnung auszugeben:

int a = 7, b = 2;
System.out.println(a / b);           // 3 - ganzzahlige Division, KEIN Fehler
System.out.println((double) a / b);  // 3.5 - erst der Cast erzwingt echte Division
System.out.println(a % b);           // 1 - Rest der Division
 
// Klassischer gerade/ungerade-Check
boolean gerade = (a % 2 == 0);

Bei negativen Zahlen rundet / in Java “Richtung Null” (nicht immer nach unten wie in manchen anderen Sprachen): -7 / 2 ergibt -3, nicht -4. Der %-Operator übernimmt bei negativen Operanden das Vorzeichen des Dividenden: -7 % 2 ergibt -1. Bei gemischten Datentypen (z. B. int und double) wandelt Java automatisch den “kleineren” Typ in den “größeren” um (implizites Type Casting), bevor gerechnet wird — bei int / int bleibt der Ausdruck aber int, selbst wenn das Ergebnis theoretisch einer double-Variable zugewiesen wird (double x = a / b; liefert immer noch 3.0, nicht 3.5, weil die Division VOR der Zuweisung ausgeführt wird).

Integer-Overflow: die zweite große Falle

Ganzzahltypen in Java haben eine feste Größe (int z. B. 32 Bit, Wertebereich ca. -2,1 bis +2,1 Milliarden). Überschreitet eine Rechnung diesen Bereich, gibt es KEINE Exception — der Wert “überläuft” stillschweigend und springt auf die andere Seite des Wertebereichs:

int max = Integer.MAX_VALUE; // 2147483647
System.out.println(max + 1);  // -2147483648 - stiller Overflow, kein Fehler!
 
long sicherer = (long) max + 1; // 2147483648 - Cast VOR der Addition verhindert den Overflow

Dieses Verhalten ist eine häufige Ursache für schwer auffindbare Bugs bei Berechnungen mit großen Zahlen (z. B. Multiplikation zweier großer int-Werte) — im Zweifel lieber long verwenden oder explizit auf Overflow prüfen (Math.addExact() wirft bei Overflow eine ArithmeticException, statt still falsch zu rechnen).

Reihenfolge und Klammerung

Java wertet arithmetische Ausdrücke nach der bekannten Punkt-vor-Strich-Regel aus (*, /, % vor +, -), mit Auswertung von links nach rechts bei gleicher Priorität. Bei komplexeren Ausdrücken empfiehlt sich trotz korrekter Regeln oft explizite Klammerung — nicht weil Java es falsch berechnen würde, sondern weil es für menschliche Leser eindeutiger ist:

int ergebnis = 10 + 5 * 2 - 3 % 2; // 10 + 10 - 1 = 19
int klarer   = 10 + (5 * 2) - (3 % 2); // dieselbe Rechnung, aber sofort verständlich

Fließkomma-Arithmetik: Vorsicht bei Vergleichen

Bei double/float können Rundungsfehler durch die binäre Gleitkomma-Darstellung entstehen (0.1 + 0.2 ergibt intern 0.30000000000000004, nicht exakt 0.3). Direkte Gleichheitsvergleiche (==) sind deshalb bei Fließkommazahlen riskant — üblich ist stattdessen ein Toleranzvergleich (Math.abs(a - b) < 0.0001).

Siehe auch: Operatoren, Type Casting, Operator Precedence