Java-Operatoren

Operatoren sind die kleinen Symbole, mit denen man etwas mit Werten tun kann: sie addieren, vergleichen, boolean-Tests kombinieren, Bits setzen oder zwischen zwei Ausdrücken entscheiden. Dieses Kapitel gibt einen Überblick über alle Operator-Kategorien in Java — jede Kategorie hat ihr eigenes Kapitel, das tiefer geht.

Die Kategorien

Javas Operatoren lassen sich in sieben Gruppen einteilen:

Es gibt außerdem instanceof (Typprüfung) und new (Objekterstellung), die sich wie Operatoren verhalten, aber an bestimmte Sprachfunktionen gebunden sind.

Arithmetisch

Die fünf arithmetischen Operatoren tun das, was sie in jeder Sprache tun, mit einer Besonderheit:

int sum     = 7 + 3;     // 10
int diff    = 7 - 3;     // 4
int product = 7 * 3;     // 21
int quotient = 7 / 3;    // 2  ← integer division truncates
int remainder = 7 % 3;   // 1

Für die Division mit reellen Zahlen muss mindestens ein Operand vom Typ double sein (oder dazu gecastet werden). Siehe Java Arithmetic Operators für die vollständige Behandlung.

Unär

int x = 5;
int neg = -x;       // -5
int inc = ++x;      // pre-increment: x becomes 6, inc is 6
int post = x++;     // post-increment: post is 6, then x becomes 7
boolean b = !true;  // false

++ und -- gibt es als Präfix- und Postfixform. Das Präfix ändert die Variable und liefert den neuen Wert; das Postfix liefert den alten Wert und ändert dann die Variable. Verwende sie möglichst nur auf einer eigenen Zeile — eingebettet in Ausdrücke sind sie eine häufige Fehlerquelle.

Zuweisung

Die grundlegende Zuweisung ist =. Die zusammengesetzten Formen kombinieren eine Operation mit der Zuweisung:

int total = 0;
total += 5;    // total = total + 5
total *= 2;    // total = total * 2
total -= 1;    // total = total - 1

Die zusammengesetzten Formen funktionieren auch mit bitweisen Operatoren (&= |= ^=) und mit Shifts (<<= >>= >>>=). Eine zusammengesetzte Zuweisung führt außerdem einen impliziten Cast zurück zum Typ der Variable durch, sodass byte b = 10; b += 5; kompiliert, obwohl b + 5 ein int ist — ein einfaches b = b + 5; würde das nicht. Siehe Java Assignment Operators für die Details.

Vergleich

boolean a = (5 > 3);   // true
boolean b = (5 == 5);  // true
boolean c = (5 != 5);  // false

== funktioniert bei primitiven Typen und Referenzen. Bei Referenzen prüft es die Objektidentität (dasselbe Objekt im Speicher), nicht die Gleichheit des Inhalts. Um Objektinhalte zu vergleichen, verwendet man .equals():

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);        // false — different objects
System.out.println(s1.equals(s2));   // true  — same contents

Das verwirrt jeden beim ersten Mal. Das Kapitel Java Comparison Operators erklärt warum.

Logisch

Die drei logischen Operatoren kombinieren Booleans:

boolean a = true && false;   // false
boolean b = true || false;   // true
boolean c = !true;           // false

&& und || werten kurzschlussartig aus — sie hören auf zu evaluieren, sobald das Ergebnis feststeht. Das ist wichtig, wenn eine Seite eine Ausnahme werfen könnte:

if (list != null && list.size() > 0) { /* ... */ }  // safe — short-circuit

Da && beim ersten false abbricht, wird list.size() nie aufgerufen, wenn list null ist — es gibt also keine NullPointerException. Das Kapitel Java Logical Operators behandelt die Kurzschlussauswertung und die nicht kurzschlussartigen Formen &/| vollständig.

Bitweise

Zur Manipulation einzelner Bits:

int and    = 0b1100 & 0b1010;   // 0b1000 = 8
int or     = 0b1100 | 0b1010;   // 0b1110 = 14
int xor    = 0b1100 ^ 0b1010;   // 0b0110 = 6
int not    = ~0;                 // -1 — all bits flipped
int left   = 1 << 4;             // 16  — shift left
int right  = 16 >> 2;            // 4   — shift right (sign-preserving)
int uright = -1 >>> 28;          // 15  — unsigned shift right

Im alltäglichen Java-Code werden diese meist nur für Flags, Hashing und Low-Level-I/O verwendet. Java Bitwise Operators geht tiefer.

Ternär

Der ternäre Operator wählt zwischen zwei Ausdrücken:

int x = 10;
String parity = (x % 2 == 0) ? "even" : "odd";   // "even"

Er wertet zu einem Wert aus, daher ist er am nützlichsten als rechte Seite einer Zuweisung oder innerhalb eines größeren Ausdrucks. Für mehrstufige Entscheidungen verwendet man besser ein echtes if/else für bessere Lesbarkeit.

Operatorpriorität

Wenn mehrere Operatoren in einem Ausdruck vorkommen, wertet Java sie in einer festgelegten Reihenfolge aus. Die wichtigsten Prioritäten, höchste zuerst:

1. ++, --, unary -, !, ~
2. *, /, %
3. +, -
4. <<, >>, >>>
5. <, <=, >, >=, instanceof
6. ==, !=
7. & (bitwise AND)
8. ^ (bitwise XOR)
9. | (bitwise OR)
10. &&
11. ||
12. ? :
13. =, +=, -=, etc.

Im Zweifelsfall Klammern setzen. Sie kosten zur Laufzeit nichts und machen die Absicht für den nächsten Leser offensichtlich.

Eine Demonstration

Was kommt als Nächstes

Die folgenden Kapitel nach Kategorie gehen auf jede Operatorgruppe im Detail ein. Java Arithmetic Operators ist das Nächste.

Übungen