02.05.01 Operatoren – der erste Kontakt

Unter Operatoren versteht man Anweisungen, die Werte manipulieren, vergleichen oder zuweisen. Dieser Beitrag beschäftigt sich mit den simpleren Operatoren in Java.

Den einfachsten Operator haben Sie bereits kennengelernt: Das Gleichheitszeichen. Mit dem Gleichheitszeichen weißen Sie Variablen einen Wert zu.

int var = 1;

Natürlich unterstützt Java auch Rechenoperationen wie Addition, Subtraktion, Division und Multiplikation.

int i1 = 5 + 5; // Addition, Ergebnis 10
int i2 = 5 - 5; // Subtraktion, Ergebnis 0
int i3 = 5 / 5; // Division, Ergebnis 1
int i4 = 5 * 5; // Multiplikation, Ergebnis 25

Mit dem Plus-Operator lassen sich nicht nur Werte addieren, sondern auch Zeichenketten verknüpfen:

int zahl1 = 6;
int zahl2 = 3;
int ergebnis = zahl1 + zahl2;
System.out.println(zahl1 + " + " + zahl2 + " = " + ergebnis);

Oder kürzer:

System.out.println("6 + 3 = " + (6 + 3));

Wie Sie sicher gerade festgestellt haben, können auch in Java Klammern gesetzt werden um Ausdrücke zu gruppieren. Selbstverständlich können Sie damit auch mehrere Rechenoperatoren in einem Schritt zusammenfassen.

int ergebnis = (2 + 5 * (5 - 2) - 1) / 4; // 4

Dabei ist zu beachten, dass Rechenoperatoren die Werte der beteiligten Variablen nicht verändern, sondern lediglich den Rückgabewert manipulieren. Wenn ein primitiver Datentyp verändert werden soll, muss der Wert mit dem Gleichheitszeichen neu gesetzt werden.

int var = 4;
System.out.println(var + 1); // Ausgabe = 5;
System.out.println(var); // Ausgabe = 4;
var = var + 1;
System.out.println(var); // Ausgabe = 5;

Es ist allerdings möglich, eine solche Variablenmanipulation verkürzt darzustellen (Verbundoperatoren). Hierzu wird das gewünschte Rechenzeichen direkt vor das Gleichheitszeichen gesetzt:

int var = 4;
System.out.println(var); // 4;
var += 3; // var = var + (int)(3);
System.out.println(var); // 7;
var *= var; // var = var * (int)(var);
System.out.println(var); // 49;
var -= 4; // var = var - (int)(4);
System.out.println(var); // 45;
var /= 10 / 2 + 5; // var = var / (int)(10 / 2 + 5);
System.out.println(var); // 4

Dabei wird der Wert hinter dem Gleichheitszeichen in den Typ der Variablen vor dem Gleichheitszeichen umgewandelt. Siehe hierzu Kapitel 02.10 Rechnen mit verschiedenen Datentypen.

Sollte der Wertebereich eines primitiven Datentyps überschritten werden, so wird am anderen Ende des Wertebereichs weiter gerechnet.

byte b = 127;
b += 1;
System.out.println(b); // -128

Ein weiterer, wichtiger Operator ist das Inkrement bzw. Dekrement. Dabei wird eine Variable um den Wert 1 erhöht (Inkrement) bzw. verringert (Dekrement). Dazu ist es nur notwendig vor, oder nach dem Namen der Variablen zwei Plus- oder Minuszeichen zu setzen.

int var = 4;
var++; // var += 1;
System.out.println(var); // 5;
var--; // var -= 1;
System.out.println(var); // 4

Wird das Plus-/Minuszeichen wie im Beispiel oben nach der Variablen geschrieben, handelt es sich um ein Postfix. Setzt man den doppelten Operator vor die Variable, handelt es sich um ein Präfix. Post- und Präfix unterscheiden sich dadurch, wann die Rechenoperation ausgeführt wird. Bei einem Präfix wird zuerst der Wert der Variablen verändert und dann dieser neue Wert zurückgegeben. Bei einem Postfix ist es umgekehrt. Dort wird zuerst der alte Wert zurückgegeben und dann erst der Wert verändert. Demonstrieren lässt sich das Ganze am Besten anhand eines Beispiels:

public class PostPraeFix {

  public static void main(String[] args) {
		
    int var = 4;
    System.out.println(var++); // Postfix, 4
    System.out.println(var); // Nachwirkungen vom Postfix, 5
    var--;
    System.out.println(var); // 4
    System.out.println(++var); // Präfix, 5
    int ergebnis = var-- + 1;
    System.out.println(ergebnis); // 6
    System.out.println(var); // 4
    var++;
    System.out.println(var); // 5
    ergebnis = --var + 1;
    System.out.println(ergebnis); // 5
  }
}

Es gibt natürlich nicht nur Rechenoperatoren und Zuweisungen, sondern auch Vergleiche, welche boolsche Werte – also true oder false – zurückliefern. Die beiden gebräuchlichsten sollten wohl == und != sein. Dabei überprüft Ersterer, ob zwei primitive Datentypen identisch sind. Letzterer überprüft, ob sie es nicht sind.

boolean gleich = 1 == 1;
boolean ungleich = 1 != 1;
boolean wahr = 1 != 2;
boolean falsch = 1 == 2;
System.out.println("1 ist 1? " + gleich);
System.out.println("1 ist nicht 1? " + ungleich);
System.out.println("1 ist nicht 2? " + wahr);
System.out.println("1 ist 2? " + falsch);

Auch können die gewöhnlichen Größer/Kleiner Vergleiche durchgeführt werden:

System.out.println("Ist 2 größer als 1? " + (2 > 1));
System.out.println("Ist 2 kleiner als 1? " + (2 < 1));&#91;/sourcecode&#93;

Diese können zudem um ein Gleichheitszeichen ergänzt werden, um zu überprüfen, ob ein Wert größer-gleich (<code>&gt;=</code>), oder ob ein Wert kleiner-gleich (<code>&lt;=</code>) zu einem anderen Wert ist.

Des weiteren besteht die Möglichkeit, boolsche Werte miteinander zu <strong>verknüpfen</strong>. Hierzu gibt es die beiden logischen Operatoren <code>&amp;&amp;</code> (und) und <code>||</code> (oder). Außerdem gibt es noch einen dritten Operator: XOR (<code>^</code>). Bei einer und-Verknüpfung wird überprüft, ob beide Werte wahr sind. Nur dann wird auch <code>true</code> zurück geliefert. Die oder-Verknüpfung testet, ob mindestens ein Wert wahr ist und gibt andernfalls <code>false</code> zurück. Um den Rückgabewert <code>true</code> bei einer XOR-Verknüpfung zu erhalten, muss ein Ausdruck <code>true</code> und der Andere <code>false</code> ergeben.

[sourcecode language="java"]boolean einsUndEinsIstZwei = true;
boolean zweiUndZweiIstVier = true;
boolean dreiUndDreiIstZwei = false;
boolean vierUndVierIstVier = false;
System.out.println(einsUndEinsIstZwei && zweiUndZweiIstVier); // true
System.out.println(einsUndEinsIstZwei || zweiUndZweiIstVier); // true
System.out.println(einsUndEinsIstZwei ^ zweiUndZweiIstVier); // false
System.out.println(dreiUndDreiIstZwei && vierUndVierIstVier); // false
System.out.println(dreiUndDreiIstZwei || vierUndVierIstVier); // false
System.out.println(dreiUndDreiIstZwei ^ vierUndVierIstVier); // false
System.out.println(einsUndEinsIstZwei && dreiUndDreiIstZwei); // false
System.out.println(zweiUndZweiIstVier || vierUndVierIstVier); // true
System.out.println(einsUndEinsIstZwei ^ vierUndVierIstVier); // true