Operator Precedence

Kurz: Die feste Reihenfolge, in der Java Operatoren in einem verschachtelten Ausdruck auswertet — Punkt-vor-Strich ist nur ein Sonderfall davon.

Genauer: Multiplikation/Division (* / %) binden stärker als Addition/Subtraktion (+ -), Vergleichsoperatoren binden schwächer als arithmetische, logisches UND (&&) bindet stärker als logisches ODER (||). Im Zweifel — oder um Lesbarkeit zu gewinnen — lohnt sich immer eine explizite Klammerung statt sich auf die Regeln zu verlassen.

Im Detail

int ergebnis = 2 + 3 * 4;        // 14, nicht 20 - * bindet stärker als +
int ergebnis2 = (2 + 3) * 4;     // 20 - explizite Klammer erzwingt andere Reihenfolge
 
boolean check = 5 > 3 && 2 < 1 || true; // && bindet stärker als ||
// entspricht: (5 > 3 && 2 < 1) || true  ->  (true && false) || true  ->  false || true  -> true
 
int x = 5;
int y = x++ + ++x; // Reihenfolge von Post-/Prä-Inkrement innerhalb eines Ausdrucks ist tückisch
// x++ liefert 5 (dann x=6), ++x liefert 7 (x war schon 6) -> y = 5 + 7 = 12, x ist jetzt 7

Grobe Rangfolge von hoch nach niedrig (Auszug): ++/-- (Inkrement/Dekrement) → * / % → + - → Vergleichsoperatoren (< > <= >=) → Gleichheitsoperatoren (== !=) → && → || → Zuweisung (= += -=, bindet am schwächsten). Das letzte Beispiel oben (x++ + ++x) zeigt, warum solche kombinierten Inkrement-Ausdrücke in echtem Code als schlechter Stil gelten, selbst wenn ihr Ergebnis technisch klar definiert ist: die Lesbarkeit leidet enorm, und ein Tippfehler zwischen Präfix- und Postfix-Form ändert das Ergebnis komplett. Die pragmatische Regel in der Praxis: bei jeder Unsicherheit über die Auswertungsreihenfolge lieber explizit klammern, statt sich auf die Präzedenztabelle zu verlassen — das kostet nichts an Performance und macht den Code für alle Lesenden sofort eindeutig.

Assoziativität als zweite Regel neben Präzedenz

Neben der reinen Rangfolge (welcher Operator “zuerst dran ist”) legt die Assoziativität fest, in welcher Richtung gleichrangige Operatoren ausgewertet werden — die meisten arithmetischen Operatoren sind linksassoziativ (10 - 3 - 2 wird als (10 - 3) - 2 = 5 gelesen, nicht als 10 - (3 - 2) = 9), während der Zuweisungsoperator rechtsassoziativ ist (a = b = c wird als a = (b = c) gelesen — deshalb funktioniert die Mehrfachzuweisung von rechts nach links). Diese Richtung ist bei gleichrangigen Operatoren genauso entscheidend wie die reine Präzedenzreihenfolge zwischen unterschiedlichen Operatoren.

Warum diese Regeln in JEDER Sprache leicht variieren

Die grundlegende Punkt-vor-Strich-Logik ist über die meisten Programmiersprachen hinweg ähnlich (an mathematische Konventionen angelehnt), aber Details wie die genaue Rangfolge von bitweisen Operatoren oder das Verhalten spezieller Operatoren unterscheiden sich zwischen Java, C++, Python und JavaScript durchaus. Wer zwischen mehreren Sprachen wechselt, sollte sich deshalb nicht blind auf “wie es in Sprache X war” verlassen, sondern im Zweifel die genaue Java-Präzedenztabelle nachschlagen oder — wie oben empfohlen — einfach klammern.

Siehe auch: Operatoren, Arithmetic Operators, Assignment Operators