Java-Operatoren: arithmetisch, Vergleich, logisch und Zuweisung

Was Operatoren tun

Operatoren sind die Symbole, die Werte kombinieren, um neue zu berechnen. Du verwendest sie bereits intuitiv - + addiert, > vergleicht - und Java fasst sie zu einigen Familien zusammen: arithmetisch, Vergleich, logisch, Zuweisung sowie ein paar Spezialfälle wie das Inkrement und der ternäre Operator.

Die meisten Operatoren nehmen zwei Werte (einen vor, einen nach dem Symbol) und liefern ein Ergebnis. Der Trick besteht darin, zu wissen, welcher Typ dieses Ergebnis ist und in welcher Reihenfolge sie angewendet werden - genau hier stolpern Anfänger.

Arithmetische Operatoren

Die fünf arithmetischen Operatoren arbeiten mit Zahlen: +, -, *, / und % (Rest).

public class Main {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;

        System.out.println(a + b);   // 22
        System.out.println(a - b);   // 12
        System.out.println(a * b);   // 85
        System.out.println(a / b);   // 3  (Ganzzahldivision!)
        System.out.println(a % b);   // 2  (der Rest)
    }
}

Der %-Operator ist der Rest nach der Division: 17 % 5 ergibt 2, weil die 5 dreimal in die 17 passt und 2 übrig bleiben. Es ist das alltägliche Werkzeug zum Prüfen der Teilbarkeit - n % 2 == 0 ist die Standardprüfung „ist n gerade?“.

Beachte außerdem, dass + eine Doppelrolle spielt: bei Zahlen addiert es, aber mit einem String auf einer der beiden Seiten verbindet es Text.

public class Main {
    public static void main(String[] args) {
        System.out.println("Total: " + 3 + 4);   // Total: 34
        System.out.println("Total: " + (3 + 4));  // Total: 7
    }
}

Die erste Zeile wird von links nach rechts gelesen: "Total: " + 3 ist bereits ein String, also wird die 4 als Text angehängt. Setze die Rechnung in Klammern, wenn du willst, dass sie zuerst berechnet wird.

Die Stolperfalle der Ganzzahldivision

Das ist die mit Abstand häufigste Überraschung. Wenn beide Operanden von / Ganzzahlen sind, führt Java eine Ganzzahldivision durch und verwirft den Bruchteil - es rundet nicht, sondern schneidet in Richtung null ab.

public class Main {
    public static void main(String[] args) {
        System.out.println(5 / 2);        // 2, nicht 2.5
        System.out.println(9 / 10);       // 0
        System.out.println(5.0 / 2);      // 2.5  (ein double genügt)
        System.out.println((double) 5 / 2); // 2.5 (einen Operanden casten)
    }
}

Um ein Dezimalergebnis zu erhalten, mache mindestens einen Operanden zu einem double - schreibe ihn entweder mit einem .0 oder caste eine Seite mit (double). (double)(5 / 2) hilft nicht, weil die Ganzzahldivision 5 / 2 bereits vor dem Cast stattgefunden hat; du musst einen Operanden casten, nicht das Ergebnis.

Vergleichsoperatoren

Vergleichsoperatoren stellen eine Ja/Nein-Frage und liefern einen boolean. Es gibt sechs: ==, !=, <, >, <=, >=.

public class Main {
    public static void main(String[] args) {
        int score = 75;

        System.out.println(score >= 60);   // true
        System.out.println(score == 100);  // false
        System.out.println(score != 0);    // true
    }
}

Achte auf den Unterschied zwischen = (Zuweisung - „leg diesen Wert hier ab“) und == (Vergleich - „sind diese gleich?“). Sie zu verwechseln ist ein klassischer Bug.

Ein wichtiger Vorbehalt: == vergleicht Objektreferenzen, nicht Inhalte. Verwende für Strings .equals().

public class Main {
    public static void main(String[] args) {
        String a = "hi";
        String b = new String("hi");

        System.out.println(a == b);        // false - verschiedene Objekte
        System.out.println(a.equals(b));   // true  - gleicher Text
    }
}

Verwende == für primitive Typen wie int und boolean, und .equals(), wann immer du den Inhalt von Objekten wie String vergleichst.

Logische Operatoren

Logische Operatoren kombinieren boolesche Werte: && (und), || (oder) und ! (nicht). So drückst du Bedingungen aus wie „alt genug und hat ein Ticket“.

public class Main {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        System.out.println(age >= 18 && hasTicket);  // true
        System.out.println(age < 13 || hasTicket);    // true
        System.out.println(!hasTicket);                // false
    }
}

&& und || werten mit Kurzschlussauswertung aus: Java hört auf zu auswerten, sobald die Antwort sicher ist. Bei && wird die rechte Seite nie geprüft, wenn die linke false ist; bei || wird die rechte übersprungen, wenn die linke true ist. Das ist nicht nur eine Optimierung - du kannst dich für die Sicherheit darauf verlassen:

if (text != null && text.length() > 0) { ... }

Wenn text null ist, ist die linke Seite false und text.length() wird nie aufgerufen, was eine NullPointerException vermeidet. Drehe die Reihenfolge um, und es würde abstürzen.

Zuweisung und Inkrement

= weist zu, aber Java hat auch zusammengesetzte Zuweisungen, die eine Operation mit einer Zuweisung verbinden: +=, -=, *=, /=, %=. Und ++ / -- addieren oder subtrahieren eins.

public class Main {
    public static void main(String[] args) {
        int count = 10;

        count += 5;   // count = count + 5  -> 15
        count -= 2;   // -> 13
        count *= 2;   // -> 26
        System.out.println(count);

        count++;      // -> 27
        count--;      // -> 26
        System.out.println(count);
    }
}

++ gibt es in zwei Varianten: postfix (count++) gibt den alten Wert zurück und inkrementiert dann; präfix (++count) inkrementiert zuerst und gibt dann den neuen Wert zurück. Der Unterschied ist nur wichtig, wenn du das Ergebnis im selben Ausdruck verwendest:

public class Main {
    public static void main(String[] args) {
        int x = 5;
        System.out.println(x++);   // gibt 5 aus, dann wird x zu 6
        System.out.println(++x);   // x wird zu 7, gibt 7 aus
    }
}

Wenn ++ in einer eigenen Zeile steht, macht postfix oder präfix keinen Unterschied - bevorzuge also die Variante, die sich klar liest, und quetsche keine Inkremente in größere Ausdrücke.

Der ternäre Operator

Der ternäre Operator condition ? a : b ist ein kompaktes if/else, das einen Wert erzeugt: ist die Bedingung true, wertet er zu a aus, andernfalls zu b.

public class Main {
    public static void main(String[] args) {
        int score = 72;

        String result = score >= 60 ? "pass" : "fail";
        System.out.println(result);   // pass

        int max = (score > 100) ? 100 : score;
        System.out.println(max);      // 72
    }
}

Er glänzt bei kurzen Entweder-oder-Zuweisungen. Widerstehe der Versuchung, ternäre Operatoren in ternäre Operatoren zu verschachteln - das wird schnell unleserlich, und ein schlichtes if/else ist klarer.

Vorrang und Klammern

Operatoren werden in einer festen Reihenfolge angewendet, ähnlich wie in der Mathematik: *, /, % binden stärker als + und -, die stärker binden als Vergleiche, die stärker binden als &&, dann ||.

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);        // 14, nicht 20
        System.out.println((2 + 3) * 4);      // 20
        System.out.println(5 > 3 && 1 < 2);   // true
    }
}

Du musst die vollständige Tabelle nicht auswendig lernen. Wenn ein Ausdruck Familien mischt oder du innehalten musst, um die Reihenfolge herauszufinden, setze Klammern - sie kosten nichts und machen die Absicht für den nächsten Leser offensichtlich.

Als Nächstes: Typumwandlung (Casting)

Mehrere Stolperfallen hier - Ganzzahldivision, das Mischen von int und double - laufen auf Typen hinaus. Das gezielte Umwandeln zwischen Zahlentypen heißt Casting, und das ist das Thema der nächsten Seite.