Priorité des opérateurs

Lors de l'évaluation d'une expression, Java applique des règles de précédence. Par exemple, dans une exprestion combinent additions numériques et concaténation de chaînes, les opérations arithmétiques sont effectuées avant la conversion en chaîne si elles précèdent l'opérateur + avec une chaîne.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println(1 + 2 + "hello" + 6 + 6);
        System.out.println(1 + 2 + "hello" + (6 + 6));
    }
}

Résultat :

3hello66
3hello12

Opérateur de concaténation de chaînes

Lorsque l’opérateur + est utilisé avec au moins un opérande de type String, Java convertit automatiquement l’autre opérande en chaîne avant de les concaténer.

public static void main(String[] args) {
    int score = 100;
    String message = "Score de mathématiques : " + score;
    String strNumber = "" + score; // Conversion implicite en String
}

Remarque : la méthode System.out.println() appelle automatiquement toString() sur ses arguments s’ils ne sont pas déjà des chaînes.

Opérateurs d’affectation composée

Ces opérateurs combinent une opération binaire avec une affetcation.

public static void main(String[] args) {
    int a = 1;
    a += 1; // équivalent à a = a + 1
    System.out.println(a); // 2

    String s = "1";
    s += s; // "11"
    System.out.println(s);

    boolean flag1 = false;
    flag1 &= true; // OK : équivalent à flag1 = flag1 & true
    System.out.println(flag1); // false

    boolean flag2 = false;
    flag2 |= true; // OK : équivalent à flag2 = flag2 | true
    System.out.println(flag2); // true
}

Note : les formes &&= ou ||= n’existent pas en Java et provoquent une erreur de compilation.

Opérateurs logiques

Java prend en charge les opérateurs suivants :

• && (ET logique court-circuit)
• || (OU logique court-circuit)
• & (ET logique sans court-circuit)
• | (OU logique sans court-circuit)
• ! (NON logique)
• ^ (XOR logique : vrai si les opérandes diffèrent)

public static void main(String[] args) {
    if (false ^ true)  System.out.println("XOR 1");
    if (true ^ false)  System.out.println("XOR 2");
    if (false ^ false) ; // non exécuté
    if (true ^ true)   ; // non exécuté
}

Seules les deux premières conditions affichent un message.

Opérateurs relationnels (de comparaison)

Les opérateurs >, <, >=, <=, == et != comparent des valeurs numériques ou des références. Leur résultat est toujours de type boolean.

Différence clé avec les opérateurs logiques : les opérateurs relationnels acceptent des opérandes numériques, tandis que les opérateurs logiques exigent des boolean. Notez que ! est un opérateur logique unaire, alors que != est un opérateur relationnel binaire.

Opérateurs bit à bit

Ces opérateurs manipulent les valeurs entières au niveau de leurs représentations binaires :

• & : ET bit à bit — 1 si les deux bits sont 1
• | : OU bit à bit — 1 si au moins un bit est 1
• ^ : XOR bit à bit — 1 si les bits diffèrent
• ~ : complément à un — inverse chaque bit
• << : décalage à gauche — décale les bits vers la gauche, remplit à droite avec des 0
• >> : décalage arithmétique à droite — conserve le signe (remplit avec le bit de signe)
• >>> : décalage logique à droite — remplit toujours avec des 0