Java™ und Objektorientierung
Java/OO kleiner Drucker Druckversion

Übersicht über Operatoren und Separatoren in JAVA

In untenstehender Tabelle sind alle in JAVA auftauchenden Operatoren und Separatoren aufgelistet.
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.

Bemerkungen:

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.


© (2006-2017) Philipp Gressly Freimann