Priorité des opérateurs et parenthèses dans les conditions

1. Introduction

Commençons par une analogie du quotidien. Imaginez une recette :

Mélangez la farine, les œufs et le sucre, fouettez, ajoutez du beurre, fouettez encore une fois.

Ça paraît étrange ? Et maintenant, imaginez qu’il y ait une virgule ou des parenthèses entre les mots « fouettez » et « ajoutez ». L’ordre des actions devient immédiatement plus clair.

En programmation, une situation similaire survient lorsque vous écrivez une expression complexe :

boolean result = a > 0 && b < 10 || c == 3;

Quel est l’ordre ? Qu’est-ce qui est évalué en premier : a > 0 && b < 10, puis || c == 3 ? Ou bien l’inverse?
Sans ordre d’évaluation clair, l’ordinateur peut « mélanger les ingrédients », et votre résultat sera inattendu.

2. Priorité des opérateurs en Java

Java (comme la plupart des langages de programmation) utilise une table de priorité des opérateurs.
Les opérateurs de priorité plus élevée sont évalués avant ceux de priorité plus faible.

Regardez la partie la plus importante de cette table (pour les expressions conditionnelles) :

()

!

==, !=

<, >, <=, >=

&&

||

(Il existe aussi des opérateurs arithmétiques — ils ont une priorité supérieure aux logiques.)

Règle principale

Les opérateurs « ET » (&&) ont une priorité plus élevée que « OU » (||),
c’est‑à‑dire que « ET » est évalué avant « OU ». Ce n’est pas un hasard si ET correspond à une multiplication logique, et OU à une addition.

Organigramme d’évaluation de la priorité des conditions

graph LR
    A["a > 0"] --&&--> B["b < 10"]
    B --||--> C["c == 3"]

(En pratique : a > 0 && b < 10 || c == 3 — d’abord a > 0 && b < 10 est évalué, puis le résultat est combiné avec c == 3 via ||.)

3. Ordre d’évaluation des opérateurs : de gauche à droite et inversement

Outre la priorité, il existe une notion : l’associativité.
C’est la règle qui indique dans quelle direction les opérateurs sont évalués lorsqu’ils se suivent et ont la même priorité.

Exemple :

boolean a = true, b = false, c = true;
boolean result = a && b && c;

Question : comment cela sera‑t‑il évalué ?
Réponse : l’associativité de && est de gauche à droite.
Donc d’abord a && b, puis le résultat avec c.

Appliqué aux conditions :

&&, ||

!

4. Les parenthèses — vos meilleures amies dans les conditions complexes

C’est là que la magie (et le salut) opèrent. Quand vous écrivez une expression, les parenthèses modifient la priorité et rendent votre code plus clair et plus sûr.

Exemple 1 (sans parenthèses) :

// Nous voulons : « Si l’utilisateur est adulte et citoyen, ou s’il possède un permis spécial »
boolean isAdult = age >= 18;
boolean isCitizen = country.equals("Biélorussie");
boolean hasPermit = hasSpecialPass == true;

if (isAdult && isCitizen || hasPermit)
{
    System.out.println("Accès autorisé !");
}

Comment Java évalue :
D’abord, elle évalue isAdult && isCitizen, puis elle combine le résultat avec hasPermit via ||.

• Supposons que isAdult = true, isCitizen = false, hasPermit = true
• isAdult && isCitizen → true && false → false
• false || true → true

Autrement dit, si la personne a un permis spécial, elle passera quand même.
Et si elle n’a pas de permis spécial mais qu’elle est un citoyen adulte — elle passera aussi.

Exemple 2 (avec parenthèses) :

if (isAdult && (isCitizen || hasPermit))
{
    System.out.println("Accès autorisé !");
}

Désormais, le programme vérifie d’abord : isCitizen || hasPermit, puis combine ce résultat avec isAdult.

Autrement dit, vous devez être adulte et (soit citoyen, soit posséder un permis spécial).
Une petite différence de parenthèses — une énorme différence de logique !