Operatori Logici Java: &&, ||, !

Gli operatori logici combinano valori boolean in test più complessi. Java ne fornisce tre: AND (&&), OR (||) e NOT (!). La caratteristica principale di && e || — ovvero il short-circuit — è ciò che li rende sicuri da usare anche quando un operando potrebbe generare un'eccezione.

Di solito si costruiscono gli operandi boolean con gli operatori di confronto (come >= o !=) e poi li si unisce con gli operatori logici di questa pagina. Questa pagina tratta ogni operatore, la valutazione short-circuit, la precedenza degli operatori, i pattern più comuni nel codice reale e le leggi di De Morgan.

I tre operatori

Operatore	Nome	Risultato
`&&`	AND	`true` solo se entrambi gli operandi sono `true`
`\|\|`	OR	`true` se almeno uno degli operandi è `true`
`!`	NOT	inverte un `boolean` — `!true` è `false`

Il comportamento completo è riassumibile in una piccola tavola della verità:

`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();
}

Nota

Gli operatori logici funzionano solo su valori boolean, non su numeri. Java non ha concetti di "truthy" o "falsy" — if (count) è un errore di compilazione; scrivi if (count > 0). Non confondere gli operatori logici &&/|| con l'operatore di confronto ==: il confronto produce il boolean, gli operatori logici ne combinano diversi.

Valutazione short-circuit

&& valuta il lato destro solo se il lato sinistro è true. Se il sinistro è false, il risultato è già noto e il destro viene saltato:

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

|| si comporta in modo speculare — salta il lato destro se il sinistro è true:

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

Questo è essenziale per i controlli null:

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

Se user è null, il lato destro viene saltato — nessuna NullPointerException. Invertirli causerebbe un crash:

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

La regola pratica: metti prima il controllo più economico, sicuro o con maggiori probabilità di fallire.

`&` e `|` senza short-circuit

Java dispone anche di & e | (a singolo carattere). Sui boolean calcolano lo stesso AND/OR, ma valutano sempre entrambi i lati. Raramente vorrai usarli così — esistono principalmente per le varianti bitwise sugli interi (trattate in Java Bitwise Operators).

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

Se ti ritrovi a usare & o | su boolean, quasi certamente vuoi && e ||.

Combinare gli operatori

Puoi concatenare gli operatori logici per costruire qualsiasi test booleano:

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

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

! ha la precedenza più alta, poi &&, poi ||. Quando li mescoli, aggiungi parentesi per chiarezza anche dove non sarebbero strettamente necessarie.

Pattern comuni

Controlli di intervallo — combina due test relazionali con &&:

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

Lista bianca — combina più uguaglianze con ||:

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

(Per liste lunghe, preferisci List.of(...).contains(status) o uno switch.)

Guard clause — fallisci subito con !:

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

Le leggi di De Morgan

Quando neghi un'espressione combinata, gli operatori si invertono:

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

Quindi !(age >= 18 && hasId) equivale a age < 18 || !hasId. La maggior parte dei lettori preferisce la forma positiva quando possibile — refactorizza verso ciò che è più facile da leggere.

Una dimostrazione

java— editable, runs on the server

Cosa vedere dopo

Java If...Else — dove questi test booleani vengono effettivamente usati per ramificare il codice.
Java Bitwise Operators — per i rari casi in cui hai davvero bisogno di manipolare bit grezzi.

Esercizio

Pratica

Quale espressione controlla in modo sicuro che user non sia null E che user.isActive() restituisca true?

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