Operatoren

Kurz: Symbole, die eine Operation auf einem oder mehreren Werten ausführen — von einfacher Arithmetik bis zu Vergleichen und Zuweisungen.

Genauer: Java gruppiert Operatoren in mehrere Kategorien: arithmetische (+ - * / %), Zuweisungs- (= += -=), Vergleichs- (== != < >) und logische (&& || !) Operatoren. Bei verschachtelten Ausdrücken entscheidet die Operator-Präzedenz, welcher Teil zuerst ausgewertet wird.

Im Detail

Kategorie	Beispiele	Zweck
Arithmetisch	+ - * / %	Rechenoperationen
Zuweisung	= += -= *= /=	Werte zuweisen/aktualisieren
Vergleich	== != < > <= >=	zwei Werte vergleichen, Ergebnis boolean
Logisch	&& || !	boolesche Ausdrücke verknüpfen
Inkrement/Dekrement	++ --	Wert um 1 erhöhen/verringern
Bitweise	& | ^ ~ << >> >>>	einzelne Bits manipulieren
Ternär	? :	kompakte if-else-Alternative als Ausdruck

Die bitweisen Operatoren (& | ^ ~ << >>) unterscheiden sich optisch nur minimal von den logischen (&& ||), verhalten sich aber fundamental anders: sie arbeiten auf der binären Darstellung von Ganzzahlen, Bit für Bit, statt auf boolean-Werten. 5 & 3 liefert z. B. 1 (binär 101 & 011 = 001), nicht etwa einen booleschen Wert — eine Verwechslung von &/| mit &&/|| kompiliert deshalb oft trotzdem (wenn beide Operanden int sind), liefert aber ein völlig anderes Ergebnis als beabsichtigt. In der alltäglichen Anwendungsentwicklung sind bitweise Operatoren selten nötig — sie tauchen vor allem bei Low-Level-Programmierung, Flags/Bitmasken oder Performance-kritischem Code auf.

int a = 5, b = 3;
System.out.println(a & b);   // 1  - bitweises UND (binär: 101 & 011 = 001)
System.out.println(a && b == 3); // Vorsicht: && erwartet boolean links - a && ... kompiliert NICHT
 
boolean x = true, y = false;
System.out.println(x & y);   // false - bitweise Variante funktioniert auch auf boolean, wertet aber IMMER beide Seiten aus
System.out.println(x && y);  // false - && wertet y nur aus, wenn x schon true ist (Short-Circuit)
 
// Ternärer Operator - kompakte Alternative zu einem einfachen if...else
int alter = 20;
String status = (alter >= 18) ? "volljährig" : "minderjährig";

Operator-Präzedenz in der Praxis

Ohne Klammern wertet Java Ausdrücke nach einer festen Rangfolge aus — Multiplikation/Division binden stärker als Addition/Subtraktion, Vergleichsoperatoren stärker als logische Verknüpfungen, und Zuweisung bindet am schwächsten von allen:

int ergebnis = 2 + 3 * 4;        // 14, nicht 20 - * bindet stärker als +
boolean check = 5 > 3 && 2 < 1;  // (5 > 3) && (2 < 1) = true && false = false

Bei komplexeren, verschachtelten Ausdrücken ist es üblich, explizite Klammern zu setzen, selbst wenn sie durch die Präzedenzregeln nicht zwingend nötig wären — das macht die Absicht für andere Lesende sofort erkennbar, ohne dass sie die komplette Rangfolge im Kopf durchgehen müssen. Details zur genauen Reihenfolge stehen in Operator Precedence.

Zusammengesetzte Zuweisungsoperatoren

+= -= *= /= sind kompakte Kurzformen, die den ursprünglichen Wert automatisch einbeziehen:

int zaehler = 10;
zaehler += 5;  // entspricht zaehler = zaehler + 5; -> 15
zaehler *= 2;  // entspricht zaehler = zaehler * 2; -> 30

Bei int-Werten enthalten diese kompakten Formen sogar einen impliziten Cast, den die ausgeschriebene Version nicht hätte: byte b = 10; b += 5; kompiliert problemlos, während b = b + 5; einen expliziten (byte)-Cast bräuchte, weil b + 5 als int-Ausdruck ausgewertet wird.

Siehe auch: Arithmetic Operators, Assignment Operators, Comparison Operators, Logical Operators, Operator Precedence