| Level | Gibt an, welche Operation zuerst ausgeführt wird. Je kleiner die
Zahl, umso stärker bindet der Operator die Operanden.
Bsp.: a = b < 5 * c wird wie folgt geklammert: a = (b < (5 * c)), denn '*' hat Priorität (Level) 3, '<' hat Prio. 6 und zuletzt '=' hat Prio. 14. Bem.: Die Einträge in Level 0 sind eigentlich keine Operatoren, stehen aber da, um die Ausführungsreihenfolge zu verdeutlichen. |
| Zeichen | Gibt an, wie der Operator in JAVA geschrieben wird. |
| Typen | Erklärt, auf welche Datentypen der Operator wirkt. |
| L/R | Gibt bei Operatoren gleicher Stufe die Klammerung (Assoziativität) an.
(L = von links nach rechts, R = von rechts nach links) 1. Beispiel: x * 5 / 17 wird wie (x * 5) / 17 geklammert (L). 2. Beispiel: a[b] = b = 0 wird wie a[b] = (b = 0) geklammert (R). Bem.: Die Klammerung hat nichts mit der Auswertungsreihenfolge zu tun: diese geht immer von links nach rechts! |
| Name | Operation in Worten. |
| Beispiel | Zeigt ein Codestück zur Veranschaulichung. |
| Beschreibung | ist eine Erläuterung zum Operator. |
| Zeichen | Typen | L/R | Name | Beispiel | Beschreibung |
| Level 0 | |||||
| ( ) | Ausdruck | L | Klammerung | 4 * (5 + j); | Klammern haben Vorrang vor allen anderen Operatoren. |
| (args) | Argumentenliste | L | Methode | println("Hallo"); | Methodenaufruf. |
| . | Objekt | L | Dereferenzierung | myObj.toString(); myArr.length; | Auf Attribute und Klassenvariabe und auf Methoden und statische Funktionen wird mit dem Punkt (.) zugegriffen. |
| [ ] | Array | L | Indexierung | myArr[i] = 77 | Zugriff auf Komponenten von Arrays (Feldern). |
| ; | Anweisung | L | Separator | x = 5; y = 7; | Zwei aufeinanderfolgende Anweisungen werden durch den Strichpunkt getrennt. Die Ausführungsreihenfolge ist die Leserichtung. |
| , | Deklaration | L | Separator | int i = 5, j = 7; | Zwei aufeinanderfolgende Deklarationen werden (auch in for()-Schleifen) durch Kommata getrennt. Die links stehende Deklaration wird zuerst ausgeführt. |
| ++ | zahl,char | L | Inkrement | x++ | Führt x = x + 1 aus. Der Wert von x++ ist gleich x vor dem Inkrement (post-Inkrement). |
| -- | zahl,char | L | Dekrement | y-- | Führt y = y - 1 aus. Der Wert von y-- ist gleich y vor dem Dekrement (post-Dekrement). |
| Level 1 | |||||
| ++ | zahl,char | R | Inkrement | ++i | Führt i = i + 1 aus. Der Wert von i++ ist gleich i nach dem Inkrement (pre-Increment). |
| -- | zahl,char | R | Dekrement | --j | Führt j = j - 1 aus. Der Wert von --j ist gleich j nach dem Dekrement (pre-Dekrement). |
| + | zahl,char | R | Vorzeichen + | z = x * (+5) | Positives Vorzeichen. Meist redundant. |
| - | zahl,char | R | Vorzeichen - | m = -5 * z; | Negatives Vorzeichen. |
| ~ | ganzzahl,char | R | Bit-Komplement | x = ~y; | Umkehrung des (dem Operanden zugehörigen) Bitmusters. ~0x35014541 == 0xCAFEBABE |
| ! | bool | R | logische Umkehrung | if(!(x == 0)) | Umkehrung des boolschen Wertes. (!true == false) |
| Level 2 | |||||
| (Typ) | R | Typumwandlung | x = (Fig) vector.elementAt(i); | Umwandlung des Operanden in den neuen Datentyp (casting). Falls es nicht möglich ist, wird eine RuntimeException auftreten. | |
| new | Klasse | R | Instanzierung | new HelloWorld(); | Erzeugen eines neuen Objektes. Dieses muss nicht zwingend einer Referenz zugewiesen werden. |
| Level 3 | |||||
| * | zahl,char | L | Multiplikation | 5 * z | Multiplikation. |
| / | zahl,char | L | Division | 5.0 / Math.PI | Division. |
| % | zahl,char | L | Modulo | 111 % 37 | Restbildung. Bsp: a) 5 % 2 == 1, b) 7.6 % 2.9 == 1.8, c) -8 % 3 == -2. Vorgehen: Vergiss alle Vorzeichen - berechne Rest - falls linker Operand negativ war, so auch das Resultat. |
| Level 4 | |||||
| + | zahl,char | L | Plus | 7 + k | Addition. |
| - | zahl,char | L | Minus | 19 - l | Subtraktion. |
| + | String | L | "concat" | "Hallo" + " Welt" == "Hallo Welt" | Zusammenfügen von Zeichenketten. |
| Level 5 | |||||
| << | ganzzahl,char | L | Linksshift | i<<2 | Bitweises Verschieben des linken Operanden um n (hier 2) Bits nach links. Die Zahl wird von rechts mit Nullen aufgefüllt.1 |
| >> | ganzzahl,char | L | Rechtsshift | j>>3 | Vorzeichenbehaftetes (signed) bitweises Verschieben des linken Operanden um n (hier 3) Bits nach rechts. Die Zahl wird von links mit dem Vorzeichen (0 = +, 1 = -) aufgefüllt. |
| >>> | ganzzahl,char | L | Rechtsshift | k>>>4 | Vorzeichenfreies (unsigned) bitweises Verschieben des linken Operanden um n (hier 4) Bits nach rechts. Die Zahl wird von links mit Nullen aufgefüllt.2 |
| Level 6 | |||||
| > | zahl,char | L | Vergleich (größer) | if (i > 5) | Liefert genau dann true, wenn der linke Operand größer ist als der rechte. |
| >= | zahl,char | L | Vergleich (größer / gleich) | if (j >= 8) | Liefert genau dann true, wenn der linke Operand größer ist als der rechte oder wenn die Operanden gleich sind. |
| < | zahl,char | L | Vergleich (kleiner) | if (k < 8) | Liefert genau dann true wenn der linke Operand kleiner ist als der rechte. |
| <= | zahl,char | L | Vergleich (kleiner / gleich) | if (m <= 4) | Liefert genau dann true, wenn der linke Operand kleiner ist als der rechte oder wenn beide gleich sind. |
| instanceof | Objekt, Typ | L | Typ Vergleich | if (myObj instanceof BankAccount) | Liefert genau dann true, wenn das linke Objekt vom gefragten Typ ist. Aber auch dann, wenn das linke Objekt eine Instanz einer davon abgeleiteten Klasse ist (Polymorphie). |
| Level 7 | |||||
| == | primitiv | L | gleicher Wert | if (0 == n) | Liefert genau dann true wenn die Werte der primitiven Variablen gleich sind. |
| != | primitiv | L | ungleicher Wert | if (0 != n) | Liefert genau dann true, wenn die Werte der primitiven Variablen nicht gleich sind, oder wenn ein Operand den Wert NaN (not a number) hat. |
| == | Objekt | L | selbe Referenz | if (this == otherObj) | Liefert genau dann true, wenn beide Referenzen auf die gleichen Objekte zeigen. Um herauszufinden, ob die Objekte gliechartig sind, verwende die Methode equals(). |
| != | Objekt | L | andere Objekte | if (this != otherObj) | Liefert genau dann true, wenn beide Referenzen auf andere Objekte zeigen. |
| Level 8 | |||||
| & | ganzzahl, char | L | bitweise UND | 0x00FF0000 & color | Liefert das (mit "und") maskierte Bitmuster (hier: Rotwert). |
| & | bool | L | logisches UND | boolC = boolA & boolB; | Liefert genau dann true, wenn beide Operatoren true sind. Handelt es sich bei den Operatoren um Ausdrücke, so werden beide berechnet. |
| Level 9 | |||||
| ^ | ganzzahl, char | L | bitweise XOR | 0x00FF0000 ^ color | Liefert das mit XOR (exklusives oder) veränderte Bitmuster. |
| ^ | bool | L | logisches XOR | boolC = boolA ^ boolB; | Liefert genau dann true, wenn die Operatoren verschiedene Wahrheitswerte haben. |
| Level 10 | |||||
| | | ganzzahl, char | L | bitweise ODER | 0x00FF0000 | color | Liefert das (mit "oder") maskierte Bitmuster. |
| | | bool | L | logisches ODER | boolC = boolA | boolB; | Liefert genau dann true, wenn einer der Operatoren true ist. Handelt es sich bei den Operatoren um Ausdrücke, so werden beide berechnet. |
| Level 11 | |||||
| && | bool | L | UND Bedingung | if(nonZero() && ok()) | Liefert true, wenn beide Operanden den Wert true haben. Falls der linke Operand bereits false ist, so wird der rechte Operand nicht ausgewertet (Kurzschlussauswertung). |
| Level 12 | |||||
| || | bool | L | ODER Bedingung | isNum() || isChar() | Liefert true, wenn einer der beiden Operanden den Wert true hat. Falls der linke Operand bereits true ist, so wird der rechte Operand nicht ausgewertet (Kurzschlussauswertung). |
| Level 13 | |||||
| ? : | bool, Anweisung, Anweisung | R | Bedingung | A ? B : C | Falls A wahr ist (true), so wird die Anweisung B ausgewertet, sonst die Anweisung C. |
| Level 14 | |||||
| = | Var., Wert | R | Zuweisung | x = 17; | Der Ausdruck rechts des Gleichheitszeichens wird berechnet. Dieser berechnete Wert wird der Variable zugewiesen. |
| *= /= %= += -= <<= >>= >>>= &= ^= |= | Var., Wert | R | Zuweisung | z *= 3 | v °= A
<==> v = (type_of_v) (v ° (A)) Dabei steht ° für einen beliebigen Operator aus der Liste. v wird beim Benutzen dieser Notation nur einmal ausgewertet. |
1
Die Anzahl Verschiebebits wird noch gekürzt. Genauer "a << b"
wird wie "a << b % 32" berechnet.
2
Achtung: Operanden vom Typ byte, char und
short
werden vor der Berechnung in int umgewandelt.