Assignment Operators

Kurz: Operatoren, die einer Variablen einen Wert zuweisen — vom einfachen = bis zu kombinierten Kurzformen wie +=.

Genauer: Kombinierte Zuweisungsoperatoren (+= -= *= /= %=) sind Kurzschreibweisen: x += 5; ist gleichbedeutend mit x = x + 5;. Das reduziert Tipparbeit und Fehlerquellen bei wiederholten Selbst-Updates einer Variable, z. B. in Schleifen.

Im Detail

Neben den arithmetischen Kurzformen gibt es auch bitweise kombinierte Zuweisungen (&= |= ^= <<= >>= >>>=) für Bit-Operationen. Wichtig: bei +=/-=/etc. führt Java bei Bedarf automatisch einen impliziten Cast durch, den eine ausgeschriebene Zuweisung so nicht erlauben würde:

byte b = 10;
b += 5;        // funktioniert - impliziter Cast zurück auf byte
// b = b + 5;  // würde NICHT kompilieren! b + 5 ist vom Typ int,
                // und int lässt sich nicht ohne expliziten Cast einem byte zuweisen
 
int x = 10;
x *= 2 + 3;    // Vorsicht: entspricht x = x * (2 + 3), also x = 50, NICHT x = x*2 + 3

Diese “versteckte” Cast-Regel bei += und Co. ist ein beliebter Klausurfehler: byte b = 10; b += 5; kompiliert, aber byte b = 10; b = b + 5; nicht, obwohl beide Zeilen inhaltlich dasselbe tun sollen. Der Grund: += ist technisch keine reine Abkürzung, sondern fügt implizit einen Cast auf den ursprünglichen Typ der Variable ein.

Inkrement/Dekrement als Sonderfall

++ und -- sind eng verwandte, aber eigenständige Operatoren (kein +=/-= mit 1) — sie existieren als Präfix (++x) und Postfix (x++) mit unterschiedlichem Rückgabewert innerhalb desselben Ausdrucks:

int x = 5;
int a = x++; // a = 5 (alter Wert wird zurückgegeben), DANACH wird x zu 6
int y = 5;
int b = ++y; // y wird ZUERST zu 6, b = 6 (neuer Wert wird zurückgegeben)

Außerhalb eines zusammengesetzten Ausdrucks (also als eigene Anweisung x++;) ist der Unterschied irrelevant — beide erhöhen x gleichermaßen um 1. Innerhalb komplexerer Ausdrücke (array[i++] = array[i]) kann die Reihenfolge aber zu subtilen, schwer nachvollziehbaren Bugs führen, weshalb viele Style-Guides empfehlen, ++/-- nicht innerhalb größerer Ausdrücke zu verschachteln.

Verkettete Zuweisungen

Der einfache Zuweisungsoperator = liefert selbst einen Wert zurück (den zugewiesenen Wert), wodurch sich mehrere Zuweisungen verketten lassen:

int a, b, c;
a = b = c = 10; // alle drei Variablen erhalten den Wert 10

Das funktioniert von rechts nach links: zuerst wird c = 10 ausgewertet (Ergebnis: 10), dann b = 10, dann a = 10. In der Praxis wird davon eher sparsam Gebrauch gemacht, da es die Lesbarkeit reduzieren kann.

Vergleich zu anderen Sprachen

Das Prinzip kombinierter Zuweisungsoperatoren (+=, -= usw.) ist nicht Java-spezifisch, sondern findet sich nahezu identisch in C, C++, JavaScript und Python (dort allerdings ohne den impliziten Narrowing-Cast von Java, da Python keine festen Ganzzahlgrößen kennt).

Siehe auch: Operatoren, Declaring Variables, Type Casting