Les opérateurs en Java

Opérateurs en Java

  Prérequis

Maîtriser les types primitifs et la déclaration de variables en Java. Connaître les notions de base sur la représentation binaire des entiers.

  Objectifs

Connaître et utiliser les différentes familles d'opérateurs Java : arithmétiques, relationnels, logiques, d'affectation et binaires. Comprendre la priorité des opérateurs pour évaluer correctement des expressions complexes.

  Vocabulaire

1. Opérateurs arithmétiques

1.1 Opérateurs binaires (deux opérandes)

int    r1 = 10 / 4;        // r1 = 2   (division entière)
double r2 = 10.0 / 4;     // r2 = 2.5 (division réelle)
double r3 = (double) 10 / 4; // r3 = 2.5 (cast explicite)

  Exemple 1 — Opérateurs arithmétiques de base

public class OperateursArith {
    public static void main(String[] args) {
        int a = 10, b = 4, res;

        res = a + b;
        System.out.println("a + b = " + res);

        res = a - b;
        System.out.println("a - b = " + res);

        res = a * b;
        System.out.println("a * b = " + res);

        res = a / b;
        System.out.println("a / b = " + res);   // division entière

        res = a % b;
        System.out.println("a % b = " + res);
    }
}

a + b = 14
a - b = 6
a * b = 40
a / b = 2
a % b = 2

1.2 Opérateurs unaires — incrémentation et décrémentation

  Exemple 2 — Pré et post incrémentation/décrémentation

public class IncrDecr {
    public static void main(String[] args) {
        int a = 10, res;

        // Post-incrémentation : res reçoit 10, PUIS a devient 11
        res = a++;
        System.out.println("post++ : a = " + a + ", res = " + res);

        // Post-décrémentation : res reçoit 11, PUIS a devient 10
        res = a--;
        System.out.println("post-- : a = " + a + ", res = " + res);

        // Pré-incrémentation : a devient 11, PUIS res reçoit 11
        res = ++a;
        System.out.println("++pre  : a = " + a + ", res = " + res);

        // Pré-décrémentation : a devient 10, PUIS res reçoit 10
        res = --a;
        System.out.println("--pre  : a = " + a + ", res = " + res);
    }
}

post++ : a = 11, res = 10
post-- : a = 10, res = 11
++pre  : a = 11, res = 11
--pre  : a = 10, res = 10

2. Opérateurs relationnels et logiques

2.1 Opérateurs relationnels

  Exemple 3 — Opérateurs relationnels

public class Relationnels {
    public static void main(String[] args) {
        int a = 10, b = 4;

        System.out.println("a > b  : " + (a > b));   // true
        System.out.println("a >= b : " + (a >= b));  // true
        System.out.println("a < b  : " + (a < b));   // false
        System.out.println("a <= b : " + (a <= b));  // false
        System.out.println("a == b : " + (a == b));  // false
        System.out.println("a != b : " + (a != b));  // true
    }
}

a > b  : true
a >= b : true
a < b  : false
a <= b : false
a == b : false
a != b : true

2.2 Opérateurs logiques

  Complément — Évaluation court-circuit

Java évalue les opérateurs logiques en court-circuit : avec &&, si le premier opérande est false, le second n'est pas évalué. Avec ||, si le premier est true, le second est ignoré. C'est utile pour éviter les erreurs (ex : tester null avant d'accéder à un objet).

String s = null;
// Court-circuit : si s == null est true, s.length() n'est pas évalué
if (s == null || s.length() == 0) {
    System.out.println("Chaîne vide ou nulle");
}

  Exemple 4 — Opérateurs logiques

public class Logiques {
    public static void main(String[] args) {
        int a = 10, b = 4, c = 10, d = 20;

        // ET logique — les deux conditions doivent être vraies
        if (a > b && c == d)
            System.out.println("a > b ET c == d");
        else
            System.out.println("condition ET non satisfaite");

        // OU logique — au moins une condition vraie suffit
        if (a > b || c == d)
            System.out.println("a > b OU c == d");
        else
            System.out.println("aucune condition satisfaite");

        // NON logique — inverse le booléen
        boolean actif = false;
        if (!actif)
            System.out.println("actif est faux");
    }
}

condition ET non satisfaite
a > b OU c == d
actif est faux

3. Opérateurs d'affectation

  Exemple 5 — Opérateurs d'affectation composés

public class Affectation {
    public static void main(String[] args) {
        int x = 10;

        x += 5;  System.out.println("x += 5  : " + x); // 15
        x -= 3;  System.out.println("x -= 3  : " + x); // 12
        x *= 2;  System.out.println("x *= 2  : " + x); // 24
        x /= 4;  System.out.println("x /= 4  : " + x); // 6
        x %= 4;  System.out.println("x %= 4  : " + x); // 2
    }
}

x += 5  : 15
x -= 3  : 12
x *= 2  : 24
x /= 4  : 6
x %= 4  : 2

4. Opérateurs binaires (bit à bit)

Pour les exemples ci-dessous : x = 10 → 0000 1010 et y = 4 → 0000 0100

  Complément — Décalages et puissances de 2

Décaler un entier de n bits vers la gauche (<< n) revient à le multiplier par 2ⁿ. Décaler vers la droite (>> n) revient à le diviser par 2ⁿ (division entière). Ces opérations sont souvent plus rapides que la multiplication ou la division classique.

int x = 10;
System.out.println(x << 1); // 20  (10 × 2)
System.out.println(x << 2); // 40  (10 × 4)
System.out.println(x >> 1); // 5   (10 / 2)
System.out.println(x >> 2); // 2   (10 / 4, troncature)

20
40
5
2

5. L'opérateur ternaire

variable = (condition) ? valeurSiVrai : valeurSiFaux;

int a = 10, b = 4;

// Équivalent à : if (a > b) max = a; else max = b;
int max = (a > b) ? a : b;
System.out.println("Maximum : " + max); // 10

// Affichage conditionnel
String signe = (a >= 0) ? "positif" : "négatif";
System.out.println("a est " + signe); // a est positif

Maximum : 10
a est positif

6. Priorité des opérateurs

  Exemple 6 — Priorité et parenthèses

int a = 2, b = 3, c = 4;

// Sans parenthèses : * avant +
int res1 = a + b * c;      // 2 + (3 * 4) = 2 + 12 = 14
System.out.println("a + b * c = " + res1);

// Avec parenthèses : + en premier
int res2 = (a + b) * c;    // (2 + 3) * 4 = 5 * 4 = 20
System.out.println("(a + b) * c = " + res2);

// Expression mixte
boolean test = a + b > c && b != 0;
// Évaluée : ((a + b) > c) && (b != 0)
//         = (5 > 4) && (3 != 0)
//         = true && true = true
System.out.println("test = " + test);

a + b * c = 14
(a + b) * c = 20
test = true

7. Exercice

public class ExerciceOperateurs {
    public static void main(String[] args) {
        int a = 5, b = 3, c = 2;

        // 1. Priorité * sur + : 5 + (3*2) = 11
        System.out.println("1. a + b * c       = " + (a + b * c));

        // 2. Parenthèses : (5+3)*2 = 16
        System.out.println("2. (a + b) * c     = " + ((a + b) * c));

        // 3. Modulo avant + : (5%3)+2 = 1+2 = 3
        System.out.println("3. a % b + c       = " + (a % b + c));

        // 4. ET logique : (5>3) && (3>2) = true && true = true
        System.out.println("4. a>b && b>c      = " + (a > b && b > c));

        // 5. Post-incr puis pré-incr (a=5, b=3)
        //    a++ retourne 5 puis a devient 6
        //    ++b incrémente b à 4 et retourne 4
        //    résultat : 5 + 4 = 9
        a = 5; b = 3; // réinitialisation
        System.out.println("5. a++ + ++b       = " + (a++ + ++b));
        System.out.println("   a après = " + a + ", b après = " + b);

        // 6. Décalage gauche de 1 bit : 5 = 0101 → 1010 = 10
        a = 5;
        System.out.println("6. a << 1          = " + (a << 1));

        // 7. Ternaire : 5 > 3 est true → retourne a = 5
        a = 5; b = 3;
        System.out.println("7. (a>b) ? a : b   = " + ((a > b) ? a : b));
    }
}

1. a + b * c       = 11
2. (a + b) * c     = 16
3. a % b + c       = 3
4. a>b && b>c      = true
5. a++ + ++b       = 9
   a après = 6, b après = 4
6. a << 1          = 10
7. (a>b) ? a : b   = 5

  L'essentiel en bref

Java propose cinq familles d'opérateurs : arithmétiques (+ - * / % ++ --), relationnels (== != > < >= <=), logiques (&& || !), d'affectation (= += -=…) et binaires (& | ^ ~ << >>). La priorité détermine l'ordre d'évaluation — les parenthèses permettent toujours de le contrôler explicitement. L'opérateur ternaire ?: offre une alternative concise au if/else simple. Les opérateurs && et || utilisent un mécanisme de court-circuit qui évite l'évaluation du second opérande si le résultat est déjà déterminé.