Welche Operatoren gibt es in Java?
Java kennt eine Vielzahl von arithmetischen, logischen, und relationalen Operatoren, sowie einen, der außerhalb von Java keine Rolle spielt. Operatoren werden nach der Anzahl der möglichen Operanden unterteilt (unärer-, binärer- und ternärer Operator) und selbstverständlich nach der Funktion, die sie berechnen. Dieses Kapitel beschreibt die verfügbaren Operatoren in Tabellenform. Bis auf wenige Ausnahmen sollten alle Operatoren und das, was sie leisten, aus der Schule bekannt sein.
Arithmetische Operatoren
| Operator | Beschreibung | Kurzbeispiel |
|---|---|---|
| + | Addition | int antwort = 40 + 2; |
| - | Subtraktion | int antwort = 48 - 6; |
| * | Multiplikation | int antwort = 2 * 21; |
| / | Division, | int antwort = 84 / 2; |
| % | Teilerrest, Modulo-Operation, errechnet den Rest einer Division | int antwort = 99 % 57; |
| + | positives Vorzeichen, in der Regel überflüssig | int j = +3; |
| - | negatives Vorzeichen | int minusJ = -j; |
Für zwei besonders in Schleifen häufig anzutreffende Berechnungen gibt es eine abkürzende Schreibweise.
| Operator | Beschreibung | Kurzbeispiel |
|---|---|---|
| ++ | Postinkrement, Addiert 1 zu einer numerischen Variable | x++; |
| ++ | Preinkrement, Addiert 1 zu einer numerischen Variable | ++x; |
| -- | Postdekrement, Subtrahiert 1 von einer numerischen Variable | x--; |
| -- | Predekrement, Subtrahiert 1 von einer numerischen Variable | --x; |
Post- und Pre-Operatoren verhalten sich bezüglich ihrer Berechnung absolut gleich, der Unterschied ist der Zeitpunkt, wann die Operation ausgeführt wird. Zum Tragen kommt das bei Zuweisungen:
i = 1;
a = ++i; // i = 2 und a = 2 (erst hochzählen, dann zuweisen)
i = 1;
b = i++; // i = 2 und b = 1 (erst zuweisen, dann hochzählen)
Operatoren für Vergleiche
Das Ergebnis dieser Operationen ist aus der Menge true, false:
| Operator | Beschreibung | Kurzbeispiel |
|---|---|---|
| == | gleich | 3 == 3 |
| != | ungleich | 4 != 3 |
| > | größer als | 4 > 3 |
| < | kleiner als | -4 < -3 |
| >= | größer als oder gleich | 3 >= 3 |
| <= | kleiner als oder gleich | -4 <= 4 |
Boolesche Operatoren
| Operator | Beschreibung | Kurzbeispiel |
|---|---|---|
| ! | Negation, invertiert den Ausdruck | boolean lügnerSpricht = !wahrheit; |
| && | Und, true, genau dann wenn beide Argumente true sind | boolean krümelmonster = istBlau && magKekse; |
| || | Oder, true, wenn mindestens ein Operand true ist | boolean machePause = hungrig || durstig; |
| ^ | Exor, true wenn genau ein Operand true ist | boolean zustandPhilosoph = denkt ^ isst; |
Operatoren zur Manipulation von Bits
| Operator | Beschreibung | Kurzbeispiel |
|---|---|---|
| ~ | (unäre) invertiert alle Bits seines Operanden | 0b10111011 = ~0b01000100 |
| & | bitweises "und", wenn beide Operanden 1 sind, wird ebenfalls eine 1 produziert, ansonsten eine 0 | 0b10111011 = 0b10111111 & 0b11111011 |
| | | bitweises "oder", produziert eine 1, sobald einer seiner Operanden eine 1 ist | 0b10111011 = 0b10001000 | 0b00111011 |
| ^ | bitweises "exklusives oder", wenn beide Operanden den gleichen Wert haben, wird eine 0 produziert, ansonsten eine 1 | 0b10111011 = 0b10001100 ^ 0b00110111 |
| Operator | Beschreibung | Kurzbeispiel |
|---|---|---|
| >> | Rechtsverschiebung, alle Bits des Operanden werden um eine Stelle nach rechts verschoben | (fehlt) |
| >>> | Rechtsverschiebung mit Auffüllung von Nullen | (fehlt) |
| << | Linksverschiebung, entspricht bei positiven ganzen Zahlen einer Multiplikation mit 2, sofern keine "1" rausgeschoben wird. | (fehlt) |
Zuweisungsoperatoren
Zu vielen Operatoren aus den vorstehenden Tabellen gehören Schreibweisen, mit denen gleichzeitig zugewiesen werden kann. Damit spart man sich oft etwas Schreibarbeit. Also, statt etwa x = x * 7; zu schreiben kann man etwas verkürzt schreiben: x *= 7;.
| Operator | Beschreibung | Kurzbeispiel |
|---|---|---|
| = | einfache Zuweisung | int var = 7; |
| += | Addiert einen Wert zu der angegebenen Variablen | plusZwei += 2; |
| -= | Subtrahiert einen Wert von der angegebenen Variablen | minusZwei -= 2; |
| /= | Dividiert die Variable durch den angegebenen Wert und weist ihn zu | viertel /= 4; |
| *= | Multipliziert die Variable mit dem angegebenen Wert und weist ihn zu | vierfach *= 4; |
| %= | Ermittelt den Modulo einer Variablen und weißt ihn der Variablen zu | restModulo11 %= 11; |
| &= | "und"-Zuweisung | maskiert &= bitmaske; |
| |= | "oder"-Zuweisung | |
| ^= | "exklusives oder"-Zuweisung | |
| ^= | bitweise "exklusive oder"-Zuweisung | |
| >>= | Rechtsverschiebungzuweisung | |
| >>>= | Rechtsverschiebungzuweisung mit Auffüllung von Nullen | |
| <<= | Linksverschiebungzuweisung | achtfach <<= 3; |
Bedingungsoperator
Den einzigen ternären Operator ?: stellen wir im Kapitel Kontrollstrukturen vor.
Konkatenation
Zwei Strings lassen sich mit "+" aneinanderschreiben, so wie Sie es schon aus früheren System.out.println("Hallo" + " Welt" + "!");-Beispielen kennen.
Vergleichsoperator instanceof
instanceofüberprüft ob ein Objekt eine Instanz einer bestimmten Klasse ist. Ein Beispiel hierzu stellen wir ihnen später vor.
Rangfolge von Operatoren
Die Rangfolge der Operatoren (engl. "operator precedence" oder auch "precedence rules") bestimmt in der Regel[1], in welcher Reihenfolge sie ausgewertet werden. Es geht darum, Klammern zu sparen. Weiß man, dass && einen höheren Rang als || hat, dann wird der Ausdruck (A && B) || C zu A && B || C. Selbstverständlich darf man trotzdem Klammern setzen.
Ganz allgemein gilt, dass Ausdrücke von links nach rechts ausgewertet werden. Das gilt nicht für Zuweisungsoperatoren.
In der folgenden Tabelle[2] werden die Operatoren und ihre Ränge aufgeführt. Je weiter oben ein Operator in der Tabelle auftaucht, desto eher wird er ausgewertet. Operatoren mit dem gleichen Rang (in der gleichen Zeile) werden von links nach rechts ausgewertet.
| Rangfolge | Typ | Operatoren |
|---|---|---|
| 1 | Postfix-Operatoren, Postinkrement, Postdekrement | x++, x-- |
| 2 | Einstellige (unäre) Operatoren, Vorzeichen | ++x, --x, +x, -x, ~b, !b |
| 3 | Multiplikation, Teilerrest | a*b, a/b, a % b |
| 4 | Addition, Subtraktion | a + b, a - b |
| 5 | Bitverschiebung | d << k, d >> k, d >>> k |
| 6 | Vergleiche | a < b, a > b, a <= b, a >= b, s instanceof S |
| 7 | Gleich, Ungleich | a == b, a != b |
| 8 | UND (Bits) | b & c |
| 9 | Exor (Bits) | b ^ c |
| 10 | ODER (Bits) | b | c |
| 11 | Logisch UND | B && C |
| 12 | Logisch ODER | B || C |
| 13 | Bedingungsoperator | a ? b : c |
| 14 | Zuweisungen | a = b, a += 3, a -= 3, a *= 3, a /= 3, a %= 3, b &= c, b ^= c, b |= c, d <<=k, d >>= k, d >>>= k |
- ↑ siehe nächsten Abschnitt Fallen
- ↑ Zum Teil entnommen von https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html
Fallen
Es gibt zum Glück wenige Fallstricke im Gebrauch von Operatoren. Postfix-Operatoren werden immer zuerst nach dem aktuellen Wert, den sie haben ausgewertet, erst dann erfolgt die Operation darauf.
Nicht in allen Fällen kann man sich bei Beachtung der Rangfolge Klammern sparen. Versuchen Sie doch einmal, den Ausdruck int x = ++y++; auszuwerten (wobei y vorher deklariert wurde). Trotz der klaren Vorrangregeln lässt sich dieser Ausdruck nicht kompilieren. Gut für alle, die einen solchen Quelltext lesen müssen...