Opérateurs logiques Java : &&, ||, !

Les opérateurs logiques combinent des valeurs boolean pour former des tests plus complexes. Java en propose trois : AND (&&), OR (||) et NOT (!). La caractéristique clé de && et || — leur court-circuit — les rend sûrs à utiliser même lorsqu'un opérande risque de lever une exception.

Vous construisez généralement les opérandes boolean à l'aide des opérateurs de comparaison (tels que >= ou !=), puis vous les assemblez avec les opérateurs logiques présentés sur cette page. Cette page couvre chaque opérateur, l'évaluation en court-circuit, la priorité des opérateurs, les patterns courants et les lois de De Morgan.

Les trois opérateurs

Opérateur	Nom	Résultat
`&&`	AND	`true` uniquement si les deux opérandes sont `true`
`\|\|`	OR	`true` si au moins un opérande est `true`
`!`	NOT	inverse un `boolean` — `!true` vaut `false`

Leur comportement complet tient en une petite table de vérité :

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

Note

Les opérateurs logiques ne fonctionnent qu'avec des valeurs boolean, pas des nombres. Java n'a pas de notion de "truthy" ou "falsy" — if (count) est une erreur de compilation ; écrivez plutôt if (count > 0). Ne confondez pas les opérateurs logiques &&/|| avec l'opérateur de comparaison == : la comparaison produit le boolean, les opérateurs logiques en combinent plusieurs.

Évaluation en court-circuit

&& n'évalue son côté droit que si le côté gauche est true. Si le gauche est false, le résultat est déjà connu et le droit est ignoré :

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

|| fonctionne en miroir — il ignore le côté droit si le gauche est true :

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

C'est essentiel pour les vérifications de null :

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

Si user est null, le côté droit est ignoré — pas de NullPointerException. Les inverser provoquerait un crash :

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

La règle d'or : placez en premier la vérification la moins coûteuse, la plus sûre ou la plus susceptible d'échouer.

Les non-court-circuit `&` et `|`

Java dispose également de & et | (un seul caractère). Sur les booléens, ils calculent le même AND/OR, mais ils évaluent toujours les deux côtés. Vous en aurez rarement besoin — ils existent principalement pour les variantes bit à bit sur les entiers (couvertes dans Java Bitwise Operators).

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

Si vous vous retrouvez à utiliser & ou | sur des booléens, vous voulez presque certainement && et ||.

Combinaison des opérateurs

Vous pouvez enchaîner les opérateurs logiques pour construire n'importe quel test booléen :

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

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

! a la priorité la plus haute, puis &&, puis ||. Lorsque vous les mélangez, ajoutez des parenthèses pour la clarté, même là où elles ne sont pas strictement nécessaires.

Patterns courants

Vérifications de plage — combinez deux tests relationnels avec && :

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

Liste blanche — combinez plusieurs égalités avec || :

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

(Pour les longues listes, préférez List.of(...).contains(status) ou un switch.)

Clauses de garde — échouez rapidement avec ! :

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

Les lois de De Morgan

Lorsque vous niez une expression combinée, les opérateurs s'inversent :

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

Ainsi !(age >= 18 && hasId) est équivalent à age < 18 || !hasId. La plupart des lecteurs préfèrent la forme positive quand c'est possible — refactorisez vers ce qui est le plus facile à lire.

Une démonstration

java— editable, runs on the server

Et ensuite

Java If...Else — là où ces tests booléens sont réellement utilisés pour brancher votre code.
Java Bitwise Operators — pour les rares moments où vous avez vraiment besoin de manipuler des bits bruts.

Pratique

Quelle expression vérifie en toute sécurité que user n'est pas null ET que user.isActive() retourne true ?

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