Bedingungen (if / else)

Bedingungen lassen dein Programm Entscheidungen treffen: "wenn die Bedingung wahr ist, mach X, sonst Y". Sie gehören in Java, Python und vielen anderen imperativen Sprachen zu den wichtigsten Kontrollstrukturen, ohne sie laufen Programme nur Schritt für Schritt ohne Auswahlentscheidung. Du lernst hier, wie du if/else/else if-Ketten korrekt schreibst, welche Vergleichs- und Logik-Operatoren in welcher Reihenfolge ausgewertet werden, wie Short-Circuit-Evaluation funktioniert und welche drei Stolperfallen in Klausuren regelmäßig Punkte kosten: Zuweisung statt Vergleich (= vs ==), String-Vergleich in Java mit == statt equals(), und falsche Reihenfolge in else-if-Ketten.

Schauen wir uns zunächst die Bausteine an, aus denen jede Bedingung zusammengesetzt ist. Eine Bedingung besteht typischerweise aus zwei Teilen: einem Vergleich (z.B. x > 5), der einen Wahrheitswert ergibt, und optional einer logischen Verknüpfung mehrerer Vergleiche (x > 5 && y < 10). Darum herum baust du die if/else-Struktur, die entscheidet, was passiert. Die wichtigsten Bausteine sind in diesen drei Kategorien:

Verzweigung:

• if: führt einen Block nur aus wenn die Bedingung true ist
• else: führt einen alternativen Block aus wenn die Bedingung false war
• else if (Java) / elif (Python): mehrere Bedingungen nacheinander prüfen

Vergleich: ==, !=, <, >, <=, >=

Logik (Verknüpfung):

• Java: && (logisches UND), || (logisches ODER), ! (logisches NICHT)
• Python: and, or, not (gleiche Semantik, aber Python liefert bei Mischtypen den letzten ausgewerteten Operanden statt eines reinen Booleans zurück, z.B. 0 or "fallback" ergibt "fallback")

In Klausuren wirst du oft gefragt: welche Ausgabe produziert dieser Code?. Achte auf die Reihenfolge der Bedingungen, else-if-Ketten werden von oben nach unten geprüft, der erste Treffer gewinnt. Hinzu kommt die häufigste Falle: == ist Vergleich, = ist Zuweisung. In Java ist if (x = 5) bei int ein Compile-Fehler (kein boolean); in Python ist if x = 5: ein Syntaxfehler.

if und else

int note = 2;

if (note <= 4) {
  System.out.println("Bestanden");
} else {
  System.out.println("Durchgefallen");
}

note = 2

if note <= 4:
    print("Bestanden")
else:
    print("Durchgefallen")

Wenn note <= 4 wahr ist, wird der erste Block ausgeführt. Wenn nicht, der zweite. Nie beide.

Mehrere Bedingungen mit else if

if (note <= 1.5) {
  System.out.println("Sehr gut");
} else if (note <= 2.5) {
  System.out.println("Gut");
} else if (note <= 4.0) {
  System.out.println("Bestanden");
} else {
  System.out.println("Durchgefallen");
}

if note <= 1.5:
    print("Sehr gut")
elif note <= 2.5:
    print("Gut")
elif note <= 4.0:
    print("Bestanden")
else:
    print("Durchgefallen")

Bedingungen werden von oben nach unten geprüft. Sobald eine wahr ist, wird der zugehörige Block ausgeführt und alle weiteren else-if-Bedingungen werden übersprungen.

Vergleichsoperatoren

Java == bei Objekten: == vergleicht bei primitiven Werten Gleichheit, bei Objekten aber Referenzgleichheit, also ob beide Variablen auf dasselbe Objekt zeigen. Für String-Inhaltsvergleich in Java s1.equals(s2) verwenden, niemals s1 == s2. Wenn s1 null sein kann: Objects.equals(s1, s2) oder "Konstante".equals(s1) (Reihenfolge umdrehen) nutzen, sonst NullPointerException.

Tückisch im Klausur-Kontext: Bei String-Literalen in deinem Quellcode (z.B. String a = "abc") speichert die JVM den Text in einem gemeinsamen Speicherbereich (dem String-Pool, der Vorgang heißt Interning). Wenn du String b = "abc" schreibst, zeigt b auf dieselbe Stelle wie a → a == b ist zufällig true. Sobald die Strings aber nicht aus Literalen entstehen, sondern z.B. via new String("abc"), durch String-Konkatenation zur Laufzeit ("a" + b mit variablem b) oder aus User-Eingaben mit scanner.next(), legt Java ein neues Objekt im Heap an (nicht im String-Pool). Dann sind es zwei verschiedene Objekte mit gleichem Inhalt → == liefert false. Genau deshalb ist == bei Strings besonders tückisch: es funktioniert zufällig solange du nur Literale verwendest, bis du Input-Strings vergleichst und plötzlich falsche Ergebnisse bekommst.

Logik-Operatoren im Detail

Die drei booleschen Verknüpfungen funktionieren in Java und Python gleich, nur die Notation unterscheidet sich. Was sie tatsächlich rechnen, zeigt die Wahrheitstabelle:

 A      B      A && B    A || B    !A
                (UND)     (ODER)    (NICHT)
 ───────────────────────────────────────
 false  false  false     false     true
 false  true   false     true      true
 true   false  false     true      false
 true   true   true      true      false

Merkregel: UND ist nur wahr wenn beide wahr sind, ODER ist schon wahr wenn mindestens einer wahr ist, NICHT dreht den Wert um.

Short-Circuit-Evaluation

Sowohl Java (&& und ||) als auch Python (and und or) werten kurzschlüssig aus: sobald das Endergebnis feststeht, wird der Rest übersprungen. Konkret:

• false && X → X wird nicht ausgewertet (Ergebnis ist eh false)
• true || X → X wird nicht ausgewertet (Ergebnis ist eh true)

Klausur-relevant wenn der zweite Operand Side-Effects hat oder zu Fehlern führen kann:

// Java: schützt vor NullPointerException
if (kunde != null && kunde.istVolljaehrig()) {
    // istVolljaehrig() wird nur gerufen wenn kunde != null
}

// Java: ohne Short-Circuit würde das crashen
if (kunde.istVolljaehrig() && kunde != null) {  // FALSCH herum!
    // istVolljaehrig() crasht bei kunde == null
}

# Python-Idiom: Default-Wert via or
name = eingabe or "Anonym"   # wenn eingabe falsy ist, nimm "Anonym"

# Python: Null-Check vor Methodenaufruf
if liste and len(liste) > 0:
    print(liste[0])   # liste kann None oder leer sein, Short-Circuit schützt

Verschachtelte Bedingungen und else-if-Ketten

Du kannst Bedingungen ineinander verschachteln. Klausur-Tipp: eine else-if-Kette ist fast immer lesbarer als drei verschachtelte if-Blöcke.

// Verschachtelt, schwerer zu lesen
if (alter >= 18) {
    if (fuehrerschein) {
        if (fahrzeug != null) {
            System.out.println("Darf fahren");
        }
    }
}

// Flach mit &&, kompakter
if (alter >= 18 && fuehrerschein && fahrzeug != null) {
    System.out.println("Darf fahren");
}

Aber Achtung: mehrere unabhängige if hintereinander sind nicht dasselbe wie eine if/else if/else-Kette:

// Variante A: 3 unabhängige if's, können MEHRERE Ausgaben erzeugen
if (note <= 1.5) System.out.println("Sehr gut");
if (note <= 2.5) System.out.println("Gut");        // bei note=1.0 läuft das AUCH
if (note <= 4.0) System.out.println("Bestanden");  // und das AUCH

// Variante B: else-if-Kette, genau EINE Ausgabe
if (note <= 1.5)       System.out.println("Sehr gut");
else if (note <= 2.5)  System.out.println("Gut");
else if (note <= 4.0)  System.out.println("Bestanden");

Variante A bei note = 1.0 gibt drei Zeilen aus, Variante B genau eine. Beliebte Klausur-Falle.

Operator-Priorität (Auswertungsreihenfolge)

Wenn ein Ausdruck mehrere Operatoren mischt, brauchst du die Priorität (welcher Operator bindet stärker). Die Reihenfolge ist in Java und Python leicht unterschiedlich für den NICHT-Operator:

JAVA (von hoch zu niedrig):                  PYTHON (von hoch zu niedrig):
1. Klammern         ()                        1. Klammern         ()
2. NICHT            !       (Unary, hoch)     2. Vergleich        ==  !=  <  >  <=  >=
3. Vergleich        ==  !=  <  >  <=  >=      3. NICHT            not    (NIEDRIGER!)
4. UND              &&                        4. UND              and
5. ODER             ||                        5. ODER             or

Wichtig: In Java ist ! ein Unary-Operator und bindet sehr stark (gleich nach Klammern). In Python ist not eine Boolean-Operation (so klassifiziert in den Python-Docs) und bindet schwächer als Vergleichsoperatoren.

Konkret an einem Beispiel:

// Java: ! bindet vor ==
boolean ergebnis = !a == b;
// → ausgewertet als (!a) == b
// → erst Negation, dann Vergleich

# Python: not bindet NACH ==
ergebnis = not a == b
# → ausgewertet als not (a == b)
# → erst Vergleich, dann Negation

Ehrliche Anmerkung: Bei zwei einfachen booleans sind beide Ausdrücke semantisch gleich (a != b), nur der Auswertungspfad unterscheidet sich. Der Unterschied wird relevant wenn:

• du Klausur-Tracing-Aufgaben machst und Zwischenschritte hinschreiben musst (mit falscher Priorität bekommst du falsche Zwischenwerte, auch wenn das Endergebnis zufällig stimmt)
• der Ausdruck mit anderen Operatoren mischt (! vs && vs == in Java; not vs and vs == in Python) und Klammern fehlen
• die Operanden Side-Effects haben (Reihenfolge bestimmt was zuerst läuft)

Faustregel: bei Unsicherheit IMMER Klammern setzen, dann sind beide Sprachen eindeutig: !(a == b) in Java, not (a == b) in Python.

Mini-Beispiel für die häufigste Klausur-Verwechslung:

// Java: x > 0 && y < 10 || admin
// wird ausgewertet als:
//   (x > 0 && y < 10) || admin
// NICHT als:
//   x > 0 && (y < 10 || admin)

int x = -5, y = 5;
boolean admin = true;

if (x > 0 && y < 10 || admin) {
    // ergibt: (false && true) || true  =  false || true  =  true
    System.out.println("Treffer");
}

Klausur-Tipp: wenn du dir bei einer Reihenfolge unsicher bist, Klammern setzen statt sich auf Priorität zu verlassen. Das macht den Code lesbar und vermeidet typische Bewertungsabzüge bei Tracing-Aufgaben.

if-else-Kette in Bewegung

Schieb den Regler hin und her und beobachte welcher Branch greift. Zur Laufzeit werden die Bedingungen von oben nach unten ausgewertet, der erste wahre Branch wird ausgeführt.

Beobachte: Sobald eine Bedingung wahr ist, werden die folgenden gar nicht mehr geprüft, bei einer if/else-if-Kette gewinnt der erste passende Branch.

Wichtig zur Abgrenzung: Das ist ein anderes Konzept als die Short-Circuit-Evaluation (oben im Erklärungs-Tab erklärt). Die if-else-if-Kette wird sequenziell Branch für Branch geprüft. Short-Circuit dagegen passiert innerhalb eines einzelnen logischen Ausdrucks wie a && b oder a || b und überspringt den zweiten Operanden wenn das Ergebnis schon feststeht. Beide Mechanismen kürzen ab, aber auf unterschiedlichen Ebenen.

---

Code-Stepper: Schritt für Schritt durchspielen

Vier interaktive Demos zu Bedingungen und Short-Circuit. Klick Step oder Auto und beobachte, wie Variablen sich ändern, welche Branches gewählt werden und wo Short-Circuit greift. Die Annotation unter dem Code erklärt jeden Schritt.

1. else-if-Kette: Noten-Bewertung (note = 2.3)

2. Short-Circuit AND (&&): zweite Bedingung wird übersprungen

Setup: stell dir vor, im Hintergrund existiert eine Methode pruefe() die zwei Dinge tut: (1) sie erhöht eine globale Zähler-Variable counter um 1, und (2) sie gibt immer true zurück. So eine Methode mit Side-Effect ist typisch für Klausuren um zu prüfen, ob du Short-Circuit verstanden hast. Beobachte im Stepper: wenn die erste Bedingung schon false ist, wird pruefe() GAR NICHT aufgerufen, Counter bleibt bei 0.

3. Short-Circuit OR (||): Default-Wert via Kurzschluss

Klassisches Python-Idiom: name = eingabe or "Anonym". Wenn eingabe truthy ist, wird "Anonym" gar nicht ausgewertet. Hier mit null-Check vor Methodenaufruf, schützt vor NullPointerException.

4. Operator-Priorität: && bindet stärker als ||

In x > 0 && y < 10 || admin wird das Ergebnis bestimmt von der Bindungsstärke: && zuerst, || zuletzt. Effektiv: (x > 0 && y < 10) || admin. Hier mit x = -5, y = 5, admin = true.

Aufgabe: Notenbewerter

Schreibe ein Programm, das je nach Note (1.0 bis 5.0) den passenden Text ausgibt: "Sehr gut" für Noten bis 1.5, "Gut" bis 2.5, "Bestanden" bis 4.0, sonst "Durchgefallen".

note = 2.3

# TODO: if-elif-else-Kette mit allen 4 Fällen

Gut

public class Main {
    public static void main(String[] args) {
        double note = 2.3;

        // TODO: if-else-Kette mit allen 4 Fällen

    }
}

Gut

Quiz: Bedingungen

Sieben Fragen zu if/else, Vergleichs- und Logik-Operatoren, klausur-typisch.