Opérateur ternaire en Java: conditions concises et subtilités

1. Expressions vs Instructions

Toutes les instructions en Java se répartissent en deux catégories: instructions (Statement) et expressions (Expression). On dit généralement qu’une instruction s’exécute, et qu’une expression se calcule. Mais ce n’est pas l’essentiel.

La principale différence entre une instruction et une expression, c’est que une expression a un résultat de calcul. Premièrement, ce résultat a un type; deuxièmement, on peut affecter ce résultat quelque part, ou l’utiliser dans une autre expression.

Exemples:

int x;

(a < 10)

i++;

x = 5;

Et qu’est-ce que cela nous apporte?

Premièrement, nous pouvons utiliser le fait que beaucoup d’instructions sont en réalité des expressions (elles ont un résultat). Par exemple, ce code fonctionnera:

int x, y, z; 
x = y = z = 1; 	// x = (y = (z = 1));

Deuxièmement, nous pouvons ignorer le résultat du calcul d’une expression, si nous le souhaitons.

console.nextLine();	// on ignore le résultat de la saisie

Ignorer le résultat d’une expression est utile, par exemple, si l’expression, en plus de produire un résultat, effectue aussi une action utile, et que cette action nous importe mais pas le résultat.

2. Opérateur ternaire

Cette astuce est déjà plus intéressante que la précédente. En Java, il existe un opérateur ternaire (à trois opérandes). Il ressemble à une forme abrégée de l’opérateur if–else:

Uslovie ? Vyrazhenie1 : Vyrazhenie2;

Si la condition est vraie, alors l’expression1 est évaluée, sinon l’expression2 est évaluée. La condition est suivie d’un point d’interrogation, et les deux expressions sont séparées par deux-points.

La principale différence entre l’opérateur ternaire et l’opérateur if-else est que l’opérateur ternaire est une expression, donc on peut affecter son résultat à quelque chose.

Par exemple, nous voulons calculer le minimum de deux nombres. Avec l’opérateur ternaire, ce code ressemble à ceci:

int a = 2;
int b = 3;
int min = a < b ?  a : b;

Ou, supposons que vous deviez affecter à une variable des valeurs différentes selon une condition. Comment faire?

Première option — utiliser l’opérateur if-else:

int age = 25;
int money;
if (age > 30)
   money = 100;
else
   money = 50;

Deuxième option — utiliser l’opérateur ternaire, c’est-à-dire une écriture abrégée de l’opérateur if-else:

int age = 25;
int money = age > 30 ? 100 : 50;

Alors, qu’est-il préférable d’utiliser: l’opérateur if-else ou l’opérateur ternaire? En termes de vitesse d’exécution, il n’y a pas de différence notable. C’est plutôt une question de lisibilité du code. Et c’est un point très important: le code doit non seulement fonctionner correctement, mais aussi être facile à lire par d’autres développeurs.

Le critère le plus simple peut être le suivant: si le code tient sur une seule ligne — utilisez l’opérateur ternaire; s’il ne tient plus sur une ligne — mieux vaut utiliser if-else.

3. Subtilités de fonctionnement

Types de valeurs

Il est important de se rappeler: les deux branches de l’opérateur ternaire (<valeur_si_vrai> et <valeur_si_faux>) doivent être du même type, ou compatibles (par exemple, toutes deux String, ou toutes deux int).

Ça fonctionne:

int a = 10, b = 20;
int max = (a > b) ? a : b; // les deux branches — int

Erreur de compilation:

int a = 10, b = 20;
// String et int sont incompatibles
String result = (a > b) ? "plus grand" : 0; // Erreur de compilation: impossible d'affecter un int à une variable de type String

Variante correcte:

int a = 10, b = 20;
String result = (a > b) ? "plus grand" : "inférieur ou égal";

Exemple: travail avec les nombres

Calculons la valeur absolue à l’aide de l’opérateur ternaire:

int number = -5;
int abs = (number >= 0) ? number : -number;
System.out.println(abs); // 5

4. Intégration de l’opérateur ternaire dans une application

Écrivons une petite application interactive: en plus du message de bienvenue, le programme dira à l’utilisateur quel âge il aura l’année prochaine et indiquera s’il sera majeur.

System.out.print("Entrez votre nom : ");
String name = console.nextLine();

System.out.print("Entrez votre âge : ");
int age = console.nextInt();

int nextYear = age + 1;
String status = (nextYear >= 18) ? "majeur" : "mineur";

System.out.println("Bonjour, " + name + " ! L'année prochaine, vous aurez " + nextYear + ". Vous serez " + status + ".");

Expliquons les détails:

La variable status est calculée via l’opérateur ternaire: si l’âge dans un an est au moins 18, alors l’utilisateur sera majeur (ou le restera).

5. Opérateurs ternaires imbriqués — attention!

L’opérateur ternaire peut être imbriqué (chaque branche peut contenir un autre ternaire). Mais… cela donne souvent mal à la tête, surtout à la personne qui lira le code après vous (même si c’est vous, dans 2 jours).

Exemple: déterminer une catégorie par âge

String category = (age < 7) ? "préscolaire" :
                  (age < 18) ? "scolaire" :
                  (age < 65) ? "adulte" : "retraité";

Table de décision:

age < 7

age < 18

age < 65

Un tel code reste lisible, mais si la logique est plus complexe — mieux vaut utiliser if-else if-else.

6. Astuce: opérateur ternaire et type boolean

Parfois, on écrit une expression du type:

boolean adult = (age >= 18) ? true : false;

Mais c’est redondant. L’expression (age >= 18) renvoie déjà un boolean. On peut donc la réduire à:

boolean adult = (age >= 18);

1

Étude/Quiz

Opérateur conditionnel, niveau 3, leçon 5

Indisponible

Opérateur conditionnel

Opérateur conditionnel: if else

Ouvrir