Operatoren 🔣

💬 Die auf dieser Seite erläuterten Operatoren sind tatsächlich noch nicht alle, die es in Java gibt. Andere Operatoren wie new, instanceof oder der Ternary-Operator passen aber viel besser in den Kontext anderer Seiten, weshalb sie dort und nicht auf dieser Seite hier zu finden sind.

Arithmetische- / Rechenoperatoren

Grundrechenarten +, -, *, /

Die vier Grundrechenarten lassen sich ganz einfach in Rechen-Ausdrücken wie in Formeln verwenden. Es sollte aber darauf geachtet werden, dass in Java wie auch sonst überall gilt: Punktrechnung (*, /) vor Strichrechnung (+, -)! Deshalb müssen wenn nötig Klammern gesetzt werden:

int number = 11;
int result = (4 + number) * 10;
System.out.println("Das Ergebnis dieser unsinnigen Rechnung ist " + result);

Modulo %

Der Modulo-Operator wird mit % notiert (hat aber nichts mit Prozentrechnung zu tun!). Ein Ausdruck mit diesem Operator hat als Wert den Rest der Division der beiden Operanden:

int modulus = 5 % 2; // Wert: 1 (Rest der Division 5/2)
modulus = 10 % 2; // Wert: 0 (Rest der Division 10/2)
modulus = 11 % 4; // Wert: 3 (Rest der Division 11/4)

Der Modulo-Operator kann etwa zur Ermittlung von geraden oder ungeraden Zahlen …

public boolean isEven(int number){
    return number % 2 == 0;
}

… oder für eine Ausgabe von Prozess-Schritten in bestimmten Intervallen genutzt werden:

// 100 Iterationen
for (int i = 0; i <= 100; i++) {
    if (i % 25 == 0) {
        System.out.println("Geschafft: " + i + " von 100");
    }
}

Dieses Beispiel erzeugt die Ausgabe:

Geschafft: 0 von 100
Geschafft: 25 von 100
Geschafft: 50 von 100
Geschafft: 75 von 100
Geschafft: 100 von 100

Post-/Pre-Increment und Post-/Pre-Decrement

Diese beiden Operatoren erhöhen (++) oder verringern (--) einen numerischen Wert um 1. Dabei spielt die Position des Operators eine Rolle: Angenommen die Variable i hat den Wert 2. Während der Ausdruck i++ zuerst nach 2 aufgelöst wird und erst dann um eins erhöht wird, wird der Ausdruck ++i zuerst erhöht und dann aufgelöst, nämlich nach 3.

Ein praktisches Beispiel (Post-Increment):

int i = 2;
System.out.println(i++);
System.out.println(i);

Da der Wert des Ausdrucks i++ zuerst “abgefragt” und dann erhöht wird, lautet die Ausgabe:

2
3

Anders ist das beim Ausdruck ++i (Pre-Increment):

int i = 2;
System.out.println(++i);
System.out.println(i);

Da der Wert des Ausdrucks i++ zuerst um 1 erhöht und dann “aufgelöst” wird:

3
3

Vergleichsoperatoren

Ausdrücke mit Vergleichsoperatoren haben immer den Wert true oder false, sind also boolsche Ausdrücke. Die meisten dieser Operatoren sollten aus dem Mathematikunterricht bekannt sein:

Vergleichsoperator Erläuterung
== ist gleich
!= ist ungleich
> ist größer als
< ist kleiner als
>= ist größer oder gleich
<= ist kleiner oder gleich

Der Wert des Ausdrucks 2 >= 6 wäre dann folgerichtig false, usw.

⚠️ Achtung: Wenn der Vergleichsoperator == zum Vergleichen von Objekten (oder besser: Objekt-Referenzen) genutzt wird nicht die semantische Gleichheit der Objekte, sondern tatsächlich die Gleichheit der Referezen überprüft. D.h. der Vergleich ist nur dann true, wenn es sich um das selbe Objekt an der selben Speicherstelle handelt!
Die Gleichheit von Objekten wird deshalb anders überprüft, nämlich mit Hilfe der equals()-Methode! Mehr dazu hier.

Logische Operatoren

💬 Auch: Boolsche Operatoren

Logische Operatoren verknüpfen mehrere Aussagen (also Ausdrücke, die true oder false sind) zu größeren, komplexeren Aussagen. So ist etwa die Aussage

i < 10

nur dann wahr, wenn i kleiner als 10 ist, die Aussage

i > 5

nur dann wahr, wenn i größer als 5 ist.

UND &&

Ausgehend vom obigen Beispiel ist nun aber die Aussage

i < 10 && i > 5

nur dann wahr, wenn beides der Fall ist. In diesem Beispiel werden die beiden Aussagen durch ein logisches UND, nämlich && verknüpft.

ODER ||

Mit einem logischen ODER || wäre der ganze Ausdruck eben auch dann wahr, wenn nur eine der Teil-Aussagen wahr ist:

i < 10 || i > 5

👩‍🏫 Natürlich ist dieses letzte Beispiel völliger Unsinn, denn jede Zahl ist entweder kleiner als 10 oder größer als 5.

⚠️ && und || und der Kurzschluss

Die logischen Operatoren && und || sind short-circuiting, d.h. der rechte Teil des Ausdrucks wird nur dann aufgelöst, wenn dies nötig ist! In 2 > 17 && 1 == 1 wird z.B. 1 == 1 nicht überprüft, da der Ausdruck nach der Auswertung von 2 > 17 bereits nur noch false sein kann!

In fast allen Fällen ist dies gewünscht, denn es spart Rechenzeit. Manchmal ist es aber wichtig, dass beide Seiten eines logischen Ausdrucks aufgelöst werden. Siehe dazu den Abschnitt zum bitweisen UND bzw. ODER (unten!).

Exklusives ODER !=

Das als Vergleichsoperator bekannte != (dort: ungleich) ist gleichzeitig auch ein logischer Operator. Er sorgt dafür, dass der Gesamtausdruck nur dann true ist, wenn nur genau eine der Teil-Aussagen wahr ist!

💬 Bei genauerem Hinsehen ist hier aber nicht etwa das selbe Symbol - also != - für zwei verschiedene Dinge verwendet worden. Vielmehr ist der Vergleichsoperator ganz automatisch auch ein logischer Operator, denn true != false ließe sich sowohl als “wahr ist ungleich unwahr”, als auch als “Einer der Ausdrücke wahr oder unwahr ist wahr lesen. Somit handelt es sich hier nicht wirklich um zwei verschiedene, sondern ein und denselben Operator - nur eben in leicht unterschiedlichen Kontexten.

NEGATION !

Um eine Aussage zu negieren (also sie zu verneinen oder logisch zu invertieren) nutzt man den Negations-Operator ! (NOT). Er sorgt dafür, dass der wahre (true) Ausdruck

(2 + 2 == 4)

unwahr (false) wird:

!(2 + 2 == 4)

Gelesen: NOT…

👨‍🏫 Es können mit Hilfe der beschriebenen logischen Operatoren beliebig lange und komplexe logische Ausdrücke gebildet werden, wie etwa
!((a > b) && (x == y)) || z

Bitweise UND & und ODER |

eng.: bit-wise and; bit-wise or

⚠️ Dieser Abschnitt ist recht komplex und evtl. nicht gut für den Einstieg geeignet. Wenn du gerade erst die Operatoren in Java kennenlernst, dann ignoriere diesen Abschnitt lieber vorerst.

Die Operatoren & und | sind zwei der Operatoren in Java, die auf Bit-Ebene arbeiten. Zwar sollen Bit-Operatoren an dieser Stelle als solche keine Rolle spielen, aber gerade bei diesen beiden lohnt es sich doch, sie sich genauer anzusehen. Denn eigentlich sind bitweise Operatoren zur Verwendung mit Zahlen gedacht, aber sie funktionieren auch mit Boolean-Werten. Immerhin ist ein boolean auch nur eine Zahl (0 oder 1 im binären System).

Sehen wir uns zunächst die Funktion von & und | zur Manipulation von Integern auf Bit-Ebene an: Der Ausdruck 42 & 11 hat den Wert 10. Dazu kommt es so:

42 hat im Binärsystem den Wert 00101010
11 hat im Binärsystem den Wert 00001011
(jeweils aufgefüllt auf 8 Stellen, also 1 Byte)

Der &-Operator vergleicht nun paarweise nacheinander alle Stellen dieser beiden Zahlen daraufhin, ob die Paare beide 1 sind (UND-Operation):

    00101010
    00001011
------------
&   00001010

Da dies nur bei zwei Stellen der Fall ist, ist das Ergebnis 00001010, was im Dezimalsystem wiederum 10 ist.

Aber warum interessiert uns das für logische Operationen? Ganz einfach: Man kann & und | auch als logische Operatoren verwenden. Der Unterschied zu den eigentlichen logischen Operatoren && und || ist, dass & und | nicht kurzschließen, d.h. es werden immer beide Seiten des logischen Ausdrucks aufgelöst (siehe Abschnitt zum Kurzschluss bei & und | oben!). Das ist dann nützlich, wenn die rechte Seite eines logischen Ausdrucks unbedingt aufgelöst werden muss, weil sie eine Operation enthält, die in jedem Fall ausgeführt werden soll:

Operatoren zur Bit-Manipulation

(Die weiteren) Operatoren zur Bit-Manipulation werden hier bewusst ausgelassen. Wer sich dennoch für ~, &, |, ^, >>, >>> und << interessiert, kann z.B. hier oder hier nachlesen.

Zuweisungsoperatoren

Zuweisungsoperatoren dienen dazu, Variablen Werte zuzuweisen. Es gibt hiervon unterschiedliche Arten…

Explizite Zuweisung =

Der einfache, explizite Zuweisungsoperator = weist den Wert des Ausdrucks rechts vom = der Variable links vom = zu:

String answerToEverything = "42";

Kombinierte Zuweisungsoperatoren

Die arithmetischen und bitweisen Operatoren lassen sich mit dem Zuweisungsoperator = kombinieren, um eine verkürzte 👉 Syntax zu erzielen:

x = x + 2;

entspricht

x += 2;

In beiden Fällen nimmt die Variable x als Wert das Ergebnis der Addition des vorherigen Wertes und 2 an.

Auf dieselbe Weise lässt sich der Zuweisungsoperator = mit den weiteren arithmetischen und bitweisen Operatoren verbinden:

+=, -=, /=, *=, %=, &=, |=, …