Operatoren in Java

Operatoren sind die Werkzeuge, mit denen du Berechnungen durchfuehrst, Werte vergleichst und logische Ausdruecke formulierst. Java hat eine grosse Auswahl an Operatoren, die du in diesem Kapitel alle kennenlernen wirst.

Arithmetische Operatoren

Die Grundrechenarten funktionieren wie erwartet:

int a = 10;
int b = 3;

System.out.println(a + b);   // 13 -- Addition
System.out.println(a - b);   // 7  -- Subtraktion
System.out.println(a * b);   // 30 -- Multiplikation
System.out.println(a / b);   // 3  -- Ganzzahl-Division!
System.out.println(a % b);   // 1  -- Modulo (Rest)

Achtung: Ganzzahl-Division

Bei der Division von zwei int-Werten wird das Ergebnis abgerundet:

System.out.println(10 / 3);    // 3 (nicht 3.33!)
System.out.println(7 / 2);     // 3 (nicht 3.5!)
System.out.println(-7 / 2);    // -3 (Richtung Null gerundet)

// Fuer genaue Division: mindestens ein double verwenden
System.out.println(10.0 / 3);    // 3.3333333333333335
System.out.println((double) 10 / 3); // 3.3333333333333335

Modulo-Operator (%)

Der Modulo-Operator gibt den Rest einer Division zurueck:

System.out.println(10 % 3);  // 1 (10 / 3 = 3 Rest 1)
System.out.println(15 % 5);  // 0 (15 / 5 = 3 Rest 0)
System.out.println(7 % 2);   // 1 (7 / 2 = 3 Rest 1)

// Praktisch: Ist eine Zahl gerade?
int zahl = 42;
if (zahl % 2 == 0) {
    System.out.println(zahl + " ist gerade");
}

Zuweisungsoperatoren

int x = 10;      // Einfache Zuweisung

x += 5;  // x = x + 5  --> 15
x -= 3;  // x = x - 3  --> 12
x *= 2;  // x = x * 2  --> 24
x /= 4;  // x = x / 4  --> 6
x %= 4;  // x = x % 4  --> 2

Inkrement und Dekrement

int zaehler = 10;

zaehler++;   // zaehler = zaehler + 1 --> 11 (Postfix)
zaehler--;   // zaehler = zaehler - 1 --> 10 (Postfix)
++zaehler;   // zaehler = zaehler + 1 --> 11 (Praefix)
--zaehler;   // zaehler = zaehler - 1 --> 10 (Praefix)

Praefix vs. Postfix:

int a = 5;
int b = a++;  // b = 5, dann a = 6 (erst zuweisen, dann erhoehen)

int c = 5;
int d = ++c;  // c = 6, dann d = 6 (erst erhoehen, dann zuweisen)

Vergleichsoperatoren

Vergleichsoperatoren liefern immer einen boolean-Wert (true oder false):

int a = 10;
int b = 20;

System.out.println(a == b);   // false -- gleich?
System.out.println(a != b);   // true  -- ungleich?
System.out.println(a > b);    // false -- groesser?
System.out.println(a < b);    // true  -- kleiner?
System.out.println(a >= b);   // false -- groesser oder gleich?
System.out.println(a <= b);   // true  -- kleiner oder gleich?

Vergleich mit Python

Java	Python	Bedeutung
==	==	Gleich
!=	!=	Ungleich
>	>	Groesser
<	<	Kleiner
>=	>=	Groesser oder gleich
<=	<=	Kleiner oder gleich

Wichtig: == vergleicht bei primitiven Typen den Wert, bei Referenztypen (Strings, Objekte) die Referenz! Verwende .equals() fuer Inhaltsvergleiche:

var s1 = new String("Hallo");
var s2 = new String("Hallo");

System.out.println(s1 == s2);       // false (verschiedene Objekte)
System.out.println(s1.equals(s2));  // true (gleicher Inhalt)

Logische Operatoren

Logische Operatoren verknuepfen boolean-Werte:

boolean a = true;
boolean b = false;

System.out.println(a && b);  // false -- UND (beide muessen true sein)
System.out.println(a || b);  // true  -- ODER (mindestens einer true)
System.out.println(!a);      // false -- NICHT (Umkehrung)

Wahrheitstabelle

a	b	a && b	a || b	!a
true	true	true	true	false
true	false	false	true	false
false	true	false	true	true
false	false	false	false	true

Short-Circuit-Auswertung

Java wertet logische Ausdruecke von links nach rechts aus und stoppt, sobald das Ergebnis feststeht:

// && stoppt beim ersten false
boolean ergebnis = false && teureBerechnung(); // teureBerechnung() wird NICHT aufgerufen

// || stoppt beim ersten true
boolean ergebnis2 = true || teureBerechnung(); // teureBerechnung() wird NICHT aufgerufen

Das ist besonders nuetzlich bei Null-Pruefungen:

String name = null;

// Ohne Short-Circuit: NullPointerException!
// if (name.length() > 0) { }

// Mit Short-Circuit: sicher!
if (name != null && name.length() > 0) {
    System.out.println("Name: " + name);
}

Ternaerer Operator (Bedingungsoperator)

Eine kompakte Alternative zu if-else:

// Statt:
String ergebnis;
if (alter >= 18) {
    ergebnis = "Volljaehrig";
} else {
    ergebnis = "Minderjaehrig";
}

// Schreibe:
var ergebnis = (alter >= 18) ? "Volljaehrig" : "Minderjaehrig";

var note = 2.3;
var bewertung = (note <= 4.0) ? "Bestanden" : "Durchgefallen";
var max = (a > b) ? a : b;
var absolutwert = (x >= 0) ? x : -x;

Bitweise Operatoren

Fuer Fortgeschrittene — Operatoren, die auf Bit-Ebene arbeiten:

int a = 0b1010;  // 10 in binaer
int b = 0b1100;  // 12 in binaer

System.out.println(a & b);  // 0b1000 = 8  -- AND
System.out.println(a | b);  // 0b1110 = 14 -- OR
System.out.println(a ^ b);  // 0b0110 = 6  -- XOR
System.out.println(~a);     // Bitweise Negation
System.out.println(a << 1); // 0b10100 = 20 -- Links-Shift (mal 2)
System.out.println(a >> 1); // 0b0101 = 5   -- Rechts-Shift (durch 2)

instanceof-Operator

Prueft, ob ein Objekt von einem bestimmten Typ ist:

Object wert = "Hallo";

if (wert instanceof String) {
    System.out.println("Ist ein String!");
}

// Seit Java 16: Pattern Matching
if (wert instanceof String s) {
    System.out.println("String mit Laenge: " + s.length());
}

Operator-Vorrang (Precedence)

Von hoechster zu niedrigster Prioritaet:

Prioritaet	Operatoren	Beschreibung
1	()	Klammern
2	++, --, !	Unary
3	*, /, %	Multiplikation
4	+, -	Addition
5	<, >, <=, >=, instanceof	Vergleich
6	==, !=	Gleichheit
7	&&	Logisches UND
8	||	Logisches ODER
9	? :	Ternaer
10	=, +=, -=, etc.	Zuweisung

Tipp: Verwende Klammern, wenn du dir unsicher bist!

// Unklar:
var ergebnis = 2 + 3 * 4;      // 14 (nicht 20!)

// Klar:
var ergebnis = 2 + (3 * 4);    // 14
var ergebnis2 = (2 + 3) * 4;   // 20

Praktische Beispiele

Notenberechnung

var note1 = 1.7;
var note2 = 2.3;
var note3 = 1.0;

var durchschnitt = (note1 + note2 + note3) / 3;
var bestanden = durchschnitt <= 4.0;
var bewertung = (durchschnitt <= 1.5) ? "Sehr gut"
              : (durchschnitt <= 2.5) ? "Gut"
              : (durchschnitt <= 3.5) ? "Befriedigend"
              : (durchschnitt <= 4.0) ? "Ausreichend"
              : "Nicht bestanden";

System.out.printf("Durchschnitt: %.1f (%s)%n", durchschnitt, bewertung);

Schaltjahr-Pruefung

int jahr = 2024;
boolean istSchaltjahr = (jahr % 4 == 0 && jahr % 100 != 0) || (jahr % 400 == 0);
System.out.println(jahr + " ist Schaltjahr: " + istSchaltjahr); // true

Rabatt-Berechnung

var preis = 99.99;
var istMitglied = true;
var menge = 5;

var rabatt = (istMitglied) ? 0.10 : 0.0;  // 10% fuer Mitglieder
rabatt += (menge >= 5) ? 0.05 : 0.0;      // 5% extra ab 5 Stueck

var endpreis = preis * menge * (1 - rabatt);
System.out.printf("Endpreis: %.2f EUR (Rabatt: %.0f%%)%n", endpreis, rabatt * 100);

Uebungen

Uebung 1: Taschenrechner

Schreibe ein Programm, das zwei Zahlen und einen Operator (+, -, *, /) einliest und das Ergebnis berechnet.

Uebung 2: Gerade/Ungerade

Schreibe ein Programm, das prueft, ob eine eingegebene Zahl gerade oder ungerade ist (mit dem Modulo-Operator).

Uebung 3: Bereich pruefung

Schreibe ein Programm, das prueft, ob eine Zahl zwischen 1 und 100 liegt (einschliesslich). Verwende logische Operatoren.

Uebung 4: Maximum von drei Zahlen

Finde das Maximum von drei Zahlen — einmal mit if-else und einmal nur mit dem ternaeren Operator.

Was kommt als Naechstes?

Jetzt kennst du Variablen, Datentypen, Strings und Operatoren — damit hast du das Fundament gelegt. In der naechsten Lektion lernst du if/else-Bedingungen, mit denen dein Programm Entscheidungen treffen kann.

Zusammenfassung

• Arithmetische Operatoren: +, -, *, /, % fuer Berechnungen
• Ganzzahl-Division rundet ab: 10 / 3 ergibt 3, nicht 3.33
• Vergleichsoperatoren (==, !=, <, >, <=, >=) liefern boolean
• Logische Operatoren (&&, ||, !) verknuepfen Bedingungen
• Short-Circuit: Java stoppt die Auswertung, sobald das Ergebnis feststeht
• Der ternaere Operator (? :) ist eine kompakte Alternative zu if/else
• Klammern machen die Reihenfolge klar und vermeiden Fehler

---