Java Logische Operatoren: &&, ||, !

Logische Operatoren verbinden boolean-Werte zu komplexeren Tests. Java stellt drei bereit: AND (&&), OR (||) und NOT (!). Das entscheidende Merkmal von && und || — ihre Kurzschlussauswertung — macht sie sicher verwendbar, auch wenn ein Operand eine Ausnahme werfen könnte.

Typischerweise bildet man die boolean-Operanden aus Vergleichsoperatoren (wie >= oder !=) und verknüpft sie dann mit den logischen Operatoren auf dieser Seite. Diese Seite behandelt jeden Operator, die Kurzschlussauswertung, die Operatorrangfolge, häufige Praxismuster und die De Morganschen Gesetze.

Die drei Operatoren

Operator	Name	Ergebnis
`&&`	AND	`true` nur wenn beide Operanden `true` sind
`\|\|`	OR	`true` wenn mindestens ein Operand `true` ist
`!`	NOT	kehrt einen `boolean` um — `!true` ist `false`

Ihr vollständiges Verhalten passt in eine kleine 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`

boolean isAdult = age >= 18;
boolean hasTicket = ticket != null;

if (isAdult && hasTicket) {
    enterCinema();
}

if (isHoliday || isWeekend) {
    sleepIn();
}

if (!isLoggedIn) {
    redirectToLogin();
}

Hinweis

Logische Operatoren funktionieren nur mit boolean-Werten, nicht mit Zahlen. Java kennt kein "truthy" oder "falsy" — if (count) ist ein Kompilierfehler; schreibe stattdessen if (count > 0). Verwechsle nicht die logischen &&/|| mit dem Vergleichsoperator ==: Ein Vergleich liefert den boolean-Wert, logische Operatoren verknüpfen mehrere davon.

Kurzschlussauswertung

&& wertet die rechte Seite nur aus, wenn die linke Seite true ist. Ist die linke Seite false, steht das Ergebnis bereits fest und die rechte wird übersprungen:

boolean leftFalse = false && expensiveCall();   // expensiveCall() never runs

|| verhält sich spiegelbildlich — es überspringt die rechte Seite, wenn die linke true ist:

boolean leftTrue = true || expensiveCall();     // expensiveCall() never runs

Dies ist unverzichtbar für Null-Prüfungen:

if (user != null && user.isActive()) { ... }

Ist user null, wird die rechte Seite übersprungen — keine NullPointerException. Die Reihenfolge umzukehren würde zum Absturz führen:

if (user.isActive() && user != null) { ... }   // NPE when user is null

Die Faustregel lautet: Stelle die günstigste, sicherste oder am häufigsten fehlschlagende Prüfung zuerst.

Nicht-kurzschließende `&` und `|`

Java besitzt auch & und | (einzelnes Zeichen). Auf Booleans berechnen sie das gleiche AND/OR, werten jedoch immer beide Seiten aus. Man benötigt dies selten — es existiert hauptsächlich für die bitweisen Varianten auf Ganzzahlen (behandelt in Java Bitweise Operatoren).

boolean a = false & expensiveCall();   // expensiveCall() DOES run
boolean b = true | expensiveCall();    // expensiveCall() DOES run

Wenn man zu & oder | auf Booleans greift, meint man fast immer && und ||.

Operatoren kombinieren

Man kann logische Operatoren verketten, um beliebige boolesche Tests zu bilden:

boolean validAge = age >= 13 && age < 120;
boolean validUser = (name != null && !name.isBlank()) && validAge;

if (isWeekend || (isHoliday && !isWorkRequired)) {
    relax();
}

! bindet am stärksten, dann &&, dann ||. Beim Mischen empfiehlt es sich, Klammern zur Verdeutlichung zu setzen, auch wenn sie nicht zwingend erforderlich sind.

Häufige Muster

Bereichsprüfungen — zwei relationale Tests mit && verbinden:

if (x >= 0 && x < array.length) { ... }

Whitelist — mehrere Gleichheitsprüfungen mit || verbinden:

if (status.equals("READY") || status.equals("RUNNING") || status.equals("DONE")) { ... }

(Bei langen Listen bevorzugt man List.of(...).contains(status) oder ein switch.)

Guard-Klauseln — schnell mit ! scheitern:

if (!isAuthenticated) {
    throw new AuthException();
}
// ... main logic ...

De Morgansche Gesetze

Wenn man einen kombinierten Ausdruck negiert, wechseln die Operatoren:

!(a && b)    is the same as    !a || !b
!(a || b)    is the same as    !a && !b

Damit ist !(age >= 18 && hasId) gleich age < 18 || !hasId. Die meisten Entwickler bevorzugen die positive Form, wenn möglich — refaktoriere hin zu dem, was am leichtesten zu lesen ist.

Eine Demonstration

java— editable, runs on the server

Was kommt als Nächstes

Java If...Else — wo diese booleschen Tests tatsächlich eingesetzt werden, um den Code zu verzweigen.
Java Bitweise Operatoren — für die seltenen Momente, in denen man wirklich rohe Bits manipulieren muss.

Übungen

Übung

Welcher Ausdruck prüft sicher, dass user nicht null ist UND user.isActive() true zurückgibt?

user != null && user.isActive()user.isActive() && user != nulluser != null & user.isActive()!(user == null) && user.isActive()