Java if-else: Bedingte Anweisungen mit Beispielen

Entscheidungen mit if treffen

Programme müssen auf Daten reagieren: bestanden oder durchgefallen, vorrätig oder ausverkauft, gültig oder nicht. Die if-Anweisung ist die Art, wie Java anhand einer Bedingung auswählt, welcher Code ausgeführt wird.

Ein if nimmt eine boolesche Bedingung in Klammern und führt den Block in geschweiften Klammern nur dann aus, wenn diese Bedingung true ist:

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

        if (score >= 60) {
            System.out.println("You passed!");
        }

        System.out.println("Done grading.");
    }
}

Die Bedingung score >= 60 ist true, also wird die Nachricht ausgegeben. Die Zeile nach der schließenden Klammer wird immer ausgeführt – sie steht außerhalb des if. Ändere score auf 40 und die „passed“-Zeile wird vollständig übersprungen.

Anders als C lässt Java dich keine Zahl dort einsetzen, wo ein Boolean hingehört. if (score) ist ein Kompilierfehler – die Bedingung muss ein echter boolean-Ausdruck sein, gebildet aus Vergleichen (>, >=, ==, !=) oder boolescher Logik (&&, ||, !).

Ein else hinzufügen

else gibt dir den „andernfalls“-Pfad: Code, der nur ausgeführt wird, wenn die Bedingung false ist:

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

        if (hour < 12) {
            System.out.println("Good morning");
        } else {
            System.out.println("Good evening");
        }
    }
}

Genau einer der beiden Blöcke wird ausgeführt – nie beide, nie keiner. Das else hat keine eigene Bedingung; es fängt einfach alles ab, was das if nicht erfasst hat.

Verketten mit else if

Wenn es mehr als zwei Ausgänge gibt, verkette Bedingungen mit else if. Java prüft sie von oben nach unten und führt den ersten Block aus, dessen Bedingung wahr ist, und überspringt dann den Rest:

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

        if (score >= 90) {
            grade = 'A';
        } else if (score >= 80) {
            grade = 'B';
        } else if (score >= 70) {
            grade = 'C';
        } else {
            grade = 'F';
        }

        System.out.println("Grade: " + grade);
    }
}

Die Reihenfolge ist wichtig. Da 84 zuerst gegen >= 90 (falsch) und dann gegen >= 80 (wahr) geprüft wird, hält es bei B an und testet die unteren Grenzen nie. Genau deshalb musst du auch nicht score >= 80 && score < 90 schreiben – den zweiten Zweig zu erreichen garantiert bereits, dass score unter 90 war. Setze deine engste oder höchstpriorisierte Bedingung zuerst.

Das abschließende else ist dein Auffangfall. Es hier wegzulassen wäre ein Kompilierfehler, da grade zum Zeitpunkt der Ausgabe möglicherweise nicht zugewiesen ist.

Werte vergleichen: == gegenüber equals()

Der häufigste if-Fehler in Java ist, Strings mit == zu vergleichen. Für primitive Typen (int, double, char, boolean) ist == korrekt. Für Objekte fragt == „ist das dasselbe Objekt im Speicher?“, während .equals() fragt „haben diese denselben Inhalt?“ – und fast immer willst du Letzteres:

public class Main {
    public static void main(String[] args) {
        String input = new String("yes");

        if (input == "yes") {
            System.out.println("matched with ==");
        }

        if (input.equals("yes")) {
            System.out.println("matched with equals()");
        }
    }
}

Nur die zweite Nachricht wird ausgegeben. Das new String("yes") ist ein anderes Objekt als das Literal "yes", also ist == false, aber der Text ist identisch, also ist .equals() true. Faustregel: Primitive verwenden ==, Objekte verwenden .equals().

Ein sicherer Trick, um eine NullPointerException zu vermeiden, wenn die Variable null sein könnte: Stelle das Literal voran – if ("yes".equals(input)) – da ein Literal nie null ist.

Bedingungen kombinieren und verschachteln

Du kannst Bedingungen mit && (und), || (oder) und ! (nicht) kombinieren oder ein if in ein anderes verschachteln, wenn eine Prüfung erst sinnvoll ist, nachdem eine vorherige bestanden wurde:

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

        if (age >= 18 && hasLicense) {
            System.out.println("Can drive");
        } else {
            System.out.println("Cannot drive");
        }

        // Verschachtelung: das Zweite nur prüfen, wenn das Erste zutrifft
        if (age >= 18) {
            if (hasLicense) {
                System.out.println("Eligible and licensed");
            }
        }
    }
}

&& und || werten kurzschlüssig aus: In a && b wertet Java b nie aus, wenn a falsch ist. Das ist praktisch, um sich gegen Fehler abzusichern – if (s != null && s.length() > 0) ist sicher, weil die Längenprüfung übersprungen wird, wenn s null ist. Bevorzuge das Kombinieren mit && gegenüber tiefer Verschachtelung, wann immer du kannst; flacher Code liest sich klarer als eine Pyramide aus Klammern.

Ein klassischer Stolperstein: ein einzelnes = ist eine Zuweisung, == ist ein Vergleich. if (x = 5) zu schreiben ist bei int ein Kompilierfehler (gut), aber if (flag = true) bei einem boolean kompiliert und weist stillschweigend zu – pass darauf auf.

Der ternäre Operator

Wenn du nur zwischen zwei Werten wählen willst, ist der ternäre Operator ?: ein kompakter Einzeiler. Lies condition ? a : b als „wenn Bedingung dann a sonst b“:

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

        String label = age >= 18 ? "adult" : "minor";
        System.out.println(label);

        int a = 7, b = 3;
        int max = a > b ? a : b;
        System.out.println("max = " + max);
    }
}

Der ternäre Operator liefert einen Wert, den du zuweisen oder direkt übergeben kannst. Behalte ihn für einfache Auswahl: Wenn einer der Zweige mehrere Anweisungen oder echte Logik braucht, bleibt ein vollständiges if-else lesbar, wo ein verschachtelter Ternär schnell zum Rätsel wird.

Ein Stolperstein: die Falle der optionalen Klammern

Java lässt dich die Klammern weglassen, wenn ein Zweig eine einzige Anweisung hat, aber das lädt zu einem subtilen Bug ein. Die Einrückung lügt:

if (loggedIn)
    System.out.println("Welcome");
    System.out.println("Loading dashboard");   // NOT part of the if!

Nur die erste Zeile wird vom if gesteuert; die zweite wird immer ausgeführt, ganz gleich was, obwohl die Einrückung etwas anderes suggeriert. Verwende immer Klammern – selbst für eine einzige Zeile – und diese ganze Fehlerklasse verschwindet.

Als Nächstes: switch

if-else if-Ketten sind perfekt, wenn jeder Zweig eine andere Bedingung prüft. Aber wenn du einen einzelnen Wert gegen viele feste Möglichkeiten prüfst – einen Wochentagsnamen, eine Menüauswahl, ein Enum – wird eine lange else if-Leiter repetitiv. Die switch-Anweisung ist genau dafür gebaut, und das ist die nächste Seite.