QCM Java - Opérateurs Ternaire, Logiques et Bitwise : Maîtrisez les Fondamentaux

Réponse correcte: A

L’opérateur ternaire en Java est officiellement appelé opérateur conditionnel (Conditional Operator). Il s’agit du seul opérateur en Java qui prend trois opérandes, d’où son surnom “ternaire”. Sa syntaxe est : condition ? valeurSiVrai : valeurSiFaux.

int age = 20;
String statut = age >= 18 ? "majeur" : "mineur";
System.out.println(statut); // Affiche: majeur

Pourquoi les autres réponses sont incorrectes :

• B (Opérateur Ternary) : “Ternary” est un terme descriptif (signifiant “à trois opérandes”), mais ce n’est pas le nom officiel en Java.
• C (Opérateur de type 3) : Ce terme n’existe pas dans la terminologie Java.
• D (Opérateur de type Ternaire) : Formulation incorrecte qui ne correspond pas à la nomenclature officielle Java.

Réponse correcte: B

L’opérateur & (AND logique) retourne true uniquement si les deux opérandes sont true. Dans ce cas, A = true et B = false, donc A & B retourne false. C’est la table de vérité classique du AND : true AND false = false.

boolean A = true;
boolean B = false;
boolean resultat = A & B;
System.out.println(resultat); // Affiche: false

// Table de vérité du AND (&)
// true  & true  = true
// true  & false = false
// false & true  = false
// false & false = false

Pourquoi les autres réponses sont incorrectes :

• A (True) : Le AND logique nécessite que les DEUX opérandes soient true pour retourner true.
• C (Une erreur) : L’expression est parfaitement valide syntaxiquement et sémantiquement.
• D (Undefined) : Java ne produit jamais de valeur “undefined” pour les opérations booléennes.

Note importante : Contrairement à && (short-circuit AND), l’opérateur & évalue toujours les deux opérandes, même si le premier est false.

Réponse correcte: C

L’opérateur ~ est l’opérateur de complément bitwise (bitwise NOT). Il inverse (toggle/flip) chaque bit de l’opérande : les 0 deviennent des 1 et les 1 deviennent des 0. C’est une opération au niveau des bits, pas une inversion logique booléenne.

int x = 5;           // En binaire: 00000000 00000000 00000000 00000101
int resultat = ~x;   // En binaire: 11111111 11111111 11111111 11111010
System.out.println(resultat); // Affiche: -6

// Explication: ~x = -(x+1)
// ~5 = -6, ~0 = -1, ~(-1) = 0

Pourquoi les autres réponses sont incorrectes :

• A (Masquer certains bits) : Le masquage de bits se fait avec l’opérateur & (AND) combiné avec un masque, pas avec ~.
• B (Combiner la valeur vraie des opérandes) : L’opérateur ~ est unaire (un seul opérande), il ne combine pas plusieurs valeurs.
• D (Inverser la valeur logique d’un opérande) : C’est le rôle de l’opérateur ! (NOT logique) pour les booléens. L’opérateur ~ travaille au niveau des bits sur les entiers.

Réponse correcte: B

L’opérateur & effectue une opération AND bit à bit. word = 0b1111 (valeur décimale 15) et mask = 0b0001 (valeur décimale 1). En appliquant le AND bit à bit, seuls les bits qui sont à 1 dans les DEUX opérandes restent à 1 dans le résultat.

int word = 0b1111;  // = 15 en décimal
int mask = 0b0001;  // = 1 en décimal
int resultat = word & mask;

//   1111 (word)
// & 0001 (mask)
// ------
//   0001 = 1 en décimal

System.out.println(resultat); // Affiche: 1

Pourquoi les autres réponses sont incorrectes :

• A (0) : Le résultat serait 0 uniquement si aucun bit n’était commun entre word et mask.
• C (2) : 2 en binaire est 0010, ce qui ne correspond pas au résultat du AND entre 1111 et 0001.
• D (3) : 3 en binaire est 0011, ce qui impliquerait que les deux derniers bits soient à 1 dans les deux opérandes.

Application pratique : Le masquage de bits avec & est couramment utilisé pour extraire des bits spécifiques d’un nombre ou vérifier si un bit particulier est activé.

Réponse correcte: C

Le symbole + en Java effectue une opération d’addition lorsqu’il est utilisé entre deux opérandes numériques (int, double, float, long, etc.). C’est l’opérateur arithmétique le plus fondamental pour additionner des valeurs.

int a = 5;
int b = 3;
int somme = a + b;
System.out.println(somme); // Affiche: 8

double x = 2.5;
double y = 3.7;
double total = x + y;
System.out.println(total); // Affiche: 6.2

Pourquoi les autres réponses sont incorrectes :

• A (Opération de concaténation) : Le + effectue une concaténation uniquement lorsqu’au moins un des opérandes est une String. Entre deux nombres, c’est une addition.
• B (Opération de multiplication) : La multiplication utilise l’opérateur *.
• D (Opération de division) : La division utilise l’opérateur /.

Point important sur la surcharge : Java “surcharge” l’opérateur + : il fait l’addition pour les nombres et la concaténation pour les chaînes. Exemple : "Age: " + 25 produit "Age: 25".