Java-Zuweisungsoperatoren

Das einfache = ist der grundlegende Zuweisungsoperator. Java bietet außerdem eine Familie von zusammengesetzten Zuweisungsoperatoren, die eine arithmetische, bitweise oder Verschiebungsoperation mit der Zuweisung selbst kombinieren. Sie sparen einige Zeichen und machen die Absicht — „diese Variable an Ort und Stelle verändern" — klarer.

Einfache Zuweisung

Die rechte Seite wird ausgewertet und dann in der linken Variablen gespeichert:

int x = 5;
int y = x + 3;
y = y * 2;
System.out.println(y);   // 16

Einige Regeln:

• Die linke Seite muss eine Variable (oder ein Array-Element oder ein Feld) sein, niemals ein Ausdruck wie (x + 1) = 5.
• Die Typen müssen übereinstimmen — oder die rechte Seite muss implizit in den Typ der linken Seite konvertierbar sein.
• Eine Zuweisung ist selbst ein Ausdruck: int a = (b = 5); setzt sowohl a als auch b auf 5.

Zusammengesetzte Zuweisungsoperatoren

Jeder arithmetische und bitweise Operator hat eine entsprechende zusammengesetzte Zuweisungsform:

In der Praxis:

int total = 0;
total += 5;    // total = 5
total += 3;    // total = 8
total *= 2;    // total = 16
total -= 1;    // total = 15
total /= 3;    // total = 5

Die bitweisen und Verschiebungsformen funktionieren auf dieselbe Weise — sie wenden die Operation auf den aktuellen Wert der Variablen an und speichern das Ergebnis zurück:

int flags = 0b0101;   // 5
flags |= 0b0010;      // set a bit  -> 0b0111 = 7
flags &= 0b0110;      // clear bits -> 0b0110 = 6
flags <<= 1;          // shift left -> 0b1100 = 12

Die rechte Seite wird als Ganzes gruppiert

x op= y ist keine blinde Textersetzung von x = x op y. Der Compiler behandelt die gesamte rechte Seite als einen Operanden, so als wäre sie geklammert — x = x op (y):

int x = 10;
x *= 2 + 3;   // x = x * (2 + 3) = 50, NOT x = x * 2 + 3 = 23
System.out.println(x);   // 50

+= mit Strings

+= verkettet auch einen string:

String greeting = "Hello";
greeting += ", world!";   // "Hello, world!"

Jedes += auf einem String erzeugt intern einen neuen string — Strings sind unveränderlich. Für Schleifen, die einen langen string aufbauen, sollte stattdessen StringBuilder verwendet werden (behandelt in Java String Concatenation).

Zusammengesetzte Zuweisung enthält eine implizite Typumwandlung

Eine subtile, aber wichtige Besonderheit: Zusammengesetzte Zuweisungsoperatoren enthalten eine implizite Typumwandlung zurück zum Typ der Variablen. Die einfache Zuweisung tut das nicht.

byte b = 10;
// b = b + 1;       // compile error: int can't fit into byte without a cast
b += 1;             // OK — compound form casts implicitly
System.out.println(b);   // 11

Dies ist gelegentlich nützlich — und gelegentlich eine stille Fehlerquelle, wenn ein Überlauf verborgen bleibt.

Zuweisung ist ein Ausdruck — aber nicht missbrauchen

Da eine Zuweisung einen Wert zurückgibt, kann man sie verketten:

int a, b, c;
a = b = c = 10;     // all three set to 10

Man kann auch innerhalb eines if-Tests zuweisen:

String line;
while ((line = reader.readLine()) != null) {
    process(line);
}

Diese Idiome sind in I/O-Schleifen verbreitet. Außerhalb von while ((x = ...) != null) sollte man separate Anweisungen bevorzugen — sie sind leichter zu lesen.

= vs ==

Die häufigste Quelle für Einzeichen-Fehler in Java ist die Verwechslung von = (Zuweisung) und == (Vergleich):

int x = 5;
// if (x = 10) { ... }   // compile error: int is not a boolean
// if (x == 10) { ... }  // OK

Bei int und den meisten Typen erkennt der Compiler den Fehler sofort, weil = ein int zurückgibt, kein boolean. Bei boolean-Variablen gibt es keinen Compilerfehler — die Zuweisung mit = gibt immer den zugewiesenen boolean zurück — daher ist besondere Vorsicht beim Testen von Flags geboten:

boolean isOpen = false;
if (isOpen = true) { ... }   // bug: this sets isOpen and is always true
if (isOpen == true) { ... }  // works, but...
if (isOpen) { ... }          // ...this is what you actually want

Eine Demonstration

Was kommt als Nächstes

Java Comparison Operators behandelt ==, !=, die relationalen Operatoren und den entscheidenden Unterschied zwischen == und .equals() bei Objekten.

Übungen