Kapitel 5: Operatoren

🎯 Lernziele

In diesem Kapitel lernst du:

• Arithmetische Operatoren (+, -, *, /, %, ++, --)
• Zuweisungsoperatoren (=, +=, -=, *=, /=)
• Vergleichsoperatoren (>, <, >=, <=, ==, !=)
• Logische Operatoren (&&, ||, !)
• Ternärer Operator (Kurzschreibweise für if-else)
• Operatorpriorität (Reihenfolge der Auswertung)

5.1 Arithmetische Operatoren: + - * / % ++ --

🧮 Grundrechenarten

Operator	Bedeutung	Beispiel	Ergebnis
+	Addition	10 + 3	13
-	Subtraktion	10 - 3	7
*	Multiplikation	10 * 3	30
/	Division	10 / 3	3 (bei int!)
%	Modulo (Rest)	10 % 3	1

📋 Beispiel: Arithmetische Operatoren

public class ArithmetikBeispiel {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        
        System.out.println("a + b = " + (a + b));  // 13
        System.out.println("a - b = " + (a - b));  // 7
        System.out.println("a * b = " + (a * b));  // 30
        System.out.println("a / b = " + (a / b));  // 3 (Integer-Division!)
        System.out.println("a % b = " + (a % b));  // 1 (Rest)
        
        // Achtung bei Division!
        double c = 10.0;
        double d = 3.0;
        System.out.println("c / d = " + (c / d));  // 3.3333333333333335
    }
}

⚠️ Wichtig: Integer-Division

// Achtung!
int ergebnis1 = 10 / 3;   // 3 (Nachkommastellen werden abgeschnitten!)
double ergebnis2 = 10.0 / 3;  // 3.3333333333333335

// Lösung: Casting
double ergebnis3 = (double) 10 / 3;  // 3.3333333333333335

🔢 Inkrement (++) und Dekrement (--)

Operator	Bedeutung	Beispiel	Ergebnis
++	Erhöht um 1	x++ oder ++x	x = x + 1
--	Verringert um 1	x-- oder --x	x = x - 1

📋 Beispiel: ++ und --

public class InkrementBeispiel {
    public static void main(String[] args) {
        int x = 5;
        
        // Post-Inkrement (x++): Wert wird nach der Verwendung erhöht
        System.out.println(x++);  // Gibt 5 aus, dann wird x zu 6
        System.out.println(x);    // 6
        
        // Pre-Inkrement (++x): Wert wird vor der Verwendung erhöht
        x = 5;  // Zurücksetzen
        System.out.println(++x);  // Erhöht x zuerst auf 6, gibt dann 6 aus
        System.out.println(x);    // 6
        
        // Das gleiche für --
        int y = 5;
        System.out.println(y--);  // 5 (dann y = 4)
        System.out.println(--y);  // 3 (erst y = 3, dann ausgeben)
    }
}

5.2 Zuweisungsoperatoren: = += -= *= /=

📝 Einfache Zuweisung (=)

int alter = 25;  // Weist 25 der Variable alter zu

🔄 Erweiterte Zuweisungsoperatoren

Operator	Bedeutung	Entspricht
+=	Addition und Zuweisung	x = x + 5
-=	Subtraktion und Zuweisung	x = x - 5
*=	Multiplikation und Zuweisung	x = x * 5
/=	Division und Zuweisung	x = x / 5
%=	Modulo und Zuweisung	x = x % 5

📋 Beispiel: Erweiterte Zuweisungsoperatoren

public class ZuweisungsBeispiel {
    public static void main(String[] args) {
        int x = 10;
        
        x += 5;  // x = x + 5 → x = 15
        System.out.println(x);  // 15
        
        x -= 3;  // x = x - 3 → x = 12
        System.out.println(x);  // 12
        
        x *= 2;  // x = x * 2 → x = 24
        System.out.println(x);  // 24
        
        x /= 4;  // x = x / 4 → x = 6
        System.out.println(x);  // 6
        
        x %= 4;  // x = x % 4 → x = 2
        System.out.println(x);  // 2
    }
}

5.3 Vergleichsoperatoren: > < >= <= == !=

⚖️ Vergleichsoperatoren (liefern boolean)

Operator	Bedeutung	Beispiel	Ergebnis
>	Größer als	10 > 3	true
<	Kleiner als	10 < 3	false
>=	Größer oder gleich	10 >= 10	true
<=	Kleiner oder gleich	10 <= 5	false
==	Gleichheit	10 == 10	true
!=	Ungleichheit	10 != 5	true

📋 Beispiel: Vergleichsoperatoren

public class VergleichBeispiel {
    public static void main(String[] args) {
        int alter = 20;
        int volljaehrigkeitsgrenze = 18;
        
        System.out.println(alter > volljaehrigkeitsgrenze);   // true
        System.out.println(alter >= volljaehrigkeitsgrenze);  // true
        System.out.println(alter < volljaehrigkeitsgrenze);   // false
        System.out.println(alter <= volljaehrigkeitsgrenze);  // false
        System.out.println(alter == volljaehrigkeitsgrenze);   // false
        System.out.println(alter != volljaehrigkeitsgrenze);   // true
    }
}

⚠️ Wichtig: == vs. =

int a = 5;
int b = 5;

// Achtung!
System.out.println(a = b);  // Weist b zu a zu, gibt 5 aus (Falsch!)
System.out.println(a == b); // Vergleicht a und b, gibt true aus (Richtig!)

5.4 Logische Operatoren: && || !

🔗 Logische Operatoren (für Bedingungen)

Operator	Bedeutung	Beispiel	Ergebnis
&&	UND (beide müssen wahr sein)	true && false	false
`		`	ODER (mindestens einer muss wahr sein)
!	NICHT (Negation)	!true	false

📋 Wahrheitstabellen

UND (&&):

A	B	A && B
true	true	true
true	false	false
false	true	false
false	false	false

ODER (||):

A	B	A || B
true	true	true
true	false	true
false	true	true
false	false	false

NICHT (!):

A	!A
true	false
false	true

📋 Beispiel: Logische Operatoren

public class LogikBeispiel {
    public static void main(String[] args) {
        int alter = 25;
        boolean hatFuehrerschein = true;
        
        // Beispiel 1: UND (&&)
        // Darf Auto fahren? Alter >= 18 UND hat Führerschein
        boolean darfAutoFahren = (alter >= 18) && hatFuehrerschein;
        System.out.println("Darf Auto fahren: " + darfAutoFahren);  // true
        
        // Beispiel 2: ODER (||)
        // Rabatt berechtigt? Alter >= 65 ODER Alter <= 18
        boolean rabattBerechtigt = (alter >= 65) || (alter <= 18);
        System.out.println("Rabatt berechtigt: " + rabattBerechtigt);  // false
        
        // Beispiel 3: NICHT (!)
        boolean istMinderjaehrig = !(alter >= 18);
        System.out.println("Ist minderjährig: " + istMinderjaehrig);  // false
    }
}

⚡ Kurzschluss-Auswertung (Short-Circuit Evaluation)

// &&: Wenn der erste Teil false ist, wird der zweite nicht mehr geprüft
int x = 5;
boolean ergebnis1 = (x < 0) && (x++ > 0);  // x < 0 ist false, x++ wird nicht ausgeführt!
System.out.println(x);  // 5 (x wurde nicht erhöht!)

// ||: Wenn der erste Teil true ist, wird der zweite nicht mehr geprüft
int y = 5;
boolean ergebnis2 = (y > 0) || (y++ > 0);  // y > 0 ist true, y++ wird nicht ausgeführt!
System.out.println(y);  // 5 (y wurde nicht erhöht!)

5.5 Ternärer Operator (Bedingungsoperator)

🎯 Syntax

// Syntax: bedingung ? wertWennTrue : wertWennFalse

// Beispiel
int alter = 20;
String status = (alter >= 18) ? "Volljährig" : "Minderjährig";
System.out.println(status);  // "Volljährig"

📋 Beispiel: Ternärer Operator

public class TernaererBeispiel {
    public static void main(String[] args) {
        int punkte = 75;
        
        // Mit if-else
        String status1;
        if (punkte >= 60) {
            status1 = "Bestanden";
        } else {
            status1 = "Nicht bestanden";
        }
        System.out.println(status1);  // "Bestanden"
        
        // Mit ternärem Operator (kürzer!)
        String status2 = (punkte >= 60) ? "Bestanden" : "Nicht bestanden";
        System.out.println(status2);  // "Bestanden"
        
        // Noch ein Beispiel: Maximum von zwei Zahlen finden
        int a = 10;
        int b = 20;
        int maximum = (a > b) ? a : b;
        System.out.println("Maximum: " + maximum);  // 20
    }
}

5.6 Operatorpriorität (Reihenfolge der Auswertung)

📊 Operatorpriorität (von hoch nach niedrig)

Priorität	Operator	Bedeutung
1	()	Klammern
2	!, ++, --	Logisches NICHT, Inkrement, Dekrement
3	*, /, %	Multiplikation, Division, Modulo
4	+, -	Addition, Subtraktion
5	>, <, >=, <=	Vergleichsoperatoren
6	==, !=	Gleichheit, Ungleichheit
7	&&	Logisches UND
8	`
9	=, +=, -=, etc.	Zuweisungsoperatoren

📋 Beispiel: Operatorpriorität

public class PrioritaetBeispiel {
    public static void main(String[] args) {
        int ergebnis1 = 10 + 5 * 2;  // 10 + (5 * 2) = 20 (nicht 30!)
        System.out.println(ergebnis1);  // 20
        
        int ergebnis2 = (10 + 5) * 2;  // (10 + 5) * 2 = 30 (Klammern ändern Priorität!)
        System.out.println(ergebnis2);  // 30
        
        boolean ergebnis3 = true || false && false;  // true || (false && false) = true
        System.out.println(ergebnis3);  // true
        
        // Klammern machen es deutlicher!
        boolean ergebnis4 = (true || false) && false;  // (true) && false = false
        System.out.println(ergebnis4);  // false
    }
}

💡 Empfehlung: Klammern verwenden!

Auch wenn du die Operatorpriorität kennst, nutze Klammern, um den Code lesbarer zu machen:

// Schwer zu lesen
boolean ergebnis = a > b && c != d || e <= f;

// Besser lesbar mit Klammern
boolean ergebnis = ((a > b) && (c != d)) || (e <= f);

📝 Zusammenfassung

In diesem Kapitel hast du gelernt:

• ✅ Arithmetische Operatoren (+, -, *, /, %, ++, --)
• ✅ Zuweisungsoperatoren (=, +=, -=, *=, /=)
• ✅ Vergleichsoperatoren (>, <, >=, <=, ==, !=)
• ✅ Logische Operatoren (&&, ||, !)
• ✅ Ternärer Operator (Kurzschreibweise für if-else)
• ✅ Operatorpriorität (Reihenfolge der Auswertung)

💡 Merksatz für Anfänger

"Bei Zweifeln über die Reihenfolge: Klammern setzen! Das macht den Code lesbarer und verhindert Fehler."

🎯 Nächste Schritte

Im nächsten Kapitel lernst du:

• Bedingte Anweisungen (if, else, switch) (Kapitel 6)
• Wie man Code nur unter bestimmten Bedingungen ausführt
• Wie man zwischen verschiedenen Optionen wählt

Bereit für Entscheidungen? Los geht's! 🚀

---

📚 Weiterführende Links:

• Oracle Java Tutorials - Operators
• Java Operator Priority

💬 Fragen?
Hinterlasse einen Kommentar!