Operatoren

Zuweisungsoperatoren   Arithmetische Operatoren   Logische Operatoren   Relationale Operatoren   Der Verkettungsoperator

Mit dem (einfachen) Zuweisungsoperator (simple assignment operator) = wird einer primitiven Variablen ein Wert von passendem Typ, oder einer Referenzvariablen ein Referenzwert zugewiesen:

int n = 3;

char ch = 'A';

float z = 3.14f;

boolean isReady = false;

Example expl = new Example(); 

Sind a und b zwei Referenzvariablen von gleichem Typ, so verweisen beide nach der Zuweisung

b = a; 

auf dasselbe Objekt.

Neben = gibt es die folgenden Zuweisungsoperatoren: +=, −=, *=, /=, %=, &=, |= und ^=. Benutzt man stellvertretend für diese Operatoren das Symbol „¤=“ und sind a und b Variablen von gleichem elementaren Typ, dann kann man eine Programmzeile der Art

a = a ¤ b;

 abgekürzt auch

a ¤= b;

schreiben.

Die arithmetischen Operatoren +, −, * und / haben im Prinzip die gleiche Bedeutung wie die mathematischen Rechenzeichen „+“, „−“, „·“ und „:“ bzw. die Vorzeichen „+“ und „−“, wobei allerdings darauf geachtet werden muss, welche Datentypen jeweils verwendet werden:

float z = 3.57f * 2; // zulässig
int n = 3.57f * 2;   // fehlerhaft: Type mismatch

Außer den selbsterklärenden Operatoren +, −, * und / gibt es noch weitere arithmetische Operatoren:

Der Rest-Operator % (integer remainder operator).
Durch a = b % c; erhält a den Rest der ganzzahligen Division von b durch c.

a = 32 % 5; // a erhält den Wert 2.

Der Inkrementoperator ++ (increment operator).
a = b++; Der Wert von b wird an a übergeben; danach wird der Wert von b um 1 erhöht.
a = ++b; Der Wert von b wird um 1 erhöht; danach wird der neue Wert von b an a übergeben.
b++; // Der Wert von b wird um 1 erhöht.

Analoges gilt für den Dekrementoperator (decrement operator) −−.

Mit den logischen Operatoren !, && , ||, &, | und ^ lassen sich logische Ausdrücke miteinander verknüpfen:

Der Verneinungsoperator ! (not operator)
Hat die Boole’sche Variable q den Wert true, so erhält p durch p = !q; den Wert false. Hat umgekehrt q den Wert false, so erhält p den Wert true.

Der UND-Operator (conditional-and operator) &&
r = p && q;  r erhält nur dann den Wert true, falls sowohl p als auch q den Wert true haben, andernfalls wird r der Wert false zugewiesen.

Der ODER-Operator (conditional-or operator) ||
r = p || q;  r erhält nur dann den Wert false, falls sowohl p als auch q den Wert false haben, andernfalls wird r der Wert true zugewiesen.

Der XOR-Operator (conditional-xor operator) ^
r = p ^ q;  r erhält nur dann den Wert true, falls entweder p oder q den Wert true hat, andernfalls wird r der Wert true zugewiesen.

Der Bedingungsoperator (conditional operator) ? :
Dieser Operator ist der einzige 3-wertige Operator in Java. Er wird am besten anhand eines Beispiels erklärt:

boolean areEqual = (x == y) ? true : false;

Falls die Variablen x und y gleiche Werte besitzen, so wird die Boole’sche Variable areEqual mit dem Wahrheitswert true belegt, anderenfalls mit dem Wert false. Ein weiteres Beispiel:

int n = (ready) ? z + 1 : z - 1;

Die relationalen Operatoren ==, != , <, <=, > und >= dienen dazu, Ausdrücke miteinander zu vergleichen und in Abhängigkeit davon einen logischen Rückgabewert zu liefern. Sind v1 und v2 zwei Referenzvariablen, so liefert der Ausdruck (v1 == v2 ) genau dann den Wahrheitswert true zurück, wenn beide auf dasselbe Objekt zeigen. Sind v1 und v2 zwei primitive Variablen, so liefert der Ausdruck (v1 == v2 ) genau dann den Wahrheitswert true zurück, wenn beide den gleichen Wert besitzen.

Der Verkettungsoperator (oder auch: Konkatenationsoperator) + hat die Aufgabe, Zeichenketten miteinander zu verketten, das heißt, deren Inhalte aneinander zu hängen und eine neue Zeichenkette zu erzeugen:

String str = "ABC" + "DEF"; // liefert "ABCDEF"