## Comprendre les opérateurs binaires Les opérateurs binaires (bitwise operators) en Java permettent de manipuler les bits individuels des types entiers. Ces opérateurs sont moins utilisés dans la programmation quotidienne, mais sont cruciaux dans certains scénarios, comme le traitement de données binaires ou l'optimisation de certains algorithmes. Dans le WebIDE, créez un nouveau fichier nommé `BitwiseDemo.java`. Copiez et collez le code suivant : ```java public class BitwiseDemo { public static void main(String[] args) { int a = 60; // 60 = 0011 1100 in binary int b = 13; // 13 = 0000 1101 in binary System.out.println("a & b = " + (a & b)); // AND System.out.println("a | b = " + (a | b)); // OR System.out.println("a ^ b = " + (a ^ b)); // XOR System.out.println("~a = " + (~a)); // NOT System.out.println("a << 2 = " + (a << 2)); // Left Shift System.out.println("a >> 2 = " + (a >> 2)); // Right Shift } } ``` Décortiquons ces opérations binaires : 1. ET (`&`) : Renvoie 1 si les deux bits sont à 1, sinon 0. - `60 & 13` = `0011 1100 & 0000 1101` = `0000 1100` (12 en décimal) 2. OU (`|`) : Renvoie 1 si au moins un bit est à 1, sinon 0. - `60 | 13` = `0011 1100 | 0000 1101` = `0011 1101` (61 en décimal) 3. OU exclusif (`^`) : Renvoie 1 si les bits sont différents, 0 s'ils sont identiques. - `60 ^ 13` = `0011 1100 ^ 0000 1101` = `0011 0001` (49 en décimal) 4. NON (`~`) : Inverse tous les bits. - `~60` = `~0011 1100` = `1100 0011` (-61 en décimal, en raison de la représentation en complément à deux) 5. Décalage à gauche (`<<`) : Décale tous les bits vers la gauche du nombre de positions spécifié. - `60 << 2` = `0011 1100 << 2` = `1111 0000` (240 en décimal) 6. Décalage à droite (`>>`) : Décale tous les bits vers la droite du nombre de positions spécifié. - `60 >> 2` = `0011 1100 >> 2` = `0000 1111` (15 en décimal) Exécutez ce programme dans le WebIDE. Vous devriez voir une sortie similaire à ceci : ``` a & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a << 2 = 240 a >> 2 = 15 ``` Comprendre les opérateurs binaires peut être difficile au début, mais ils sont très puissants pour certains types d'opérations, en particulier lorsqu'on travaille avec la programmation de bas niveau ou qu'on optimise le code pour des raisons de performance.