Les instructions conditionnelles en Java permettent de contrôler le flux d’exécution du programme en fonction de certaines conditions. Elles permettent d’exécuter un bloc de code si une condition est vraie et un autre bloc de code si la condition est fausse. Dans cet article, nous explorerons en détail les différentes instructions conditionnelles disponibles en Java, leur syntaxe, leur utilisation et leurs bonnes pratiques.

L’instruction if

L’instruction if est la plus fondamentale parmi les instructions conditionnelles en Java. Elle permet d’exécuter un bloc de code si une condition est vraie. Voici la syntaxe de base :

if (condition) {
    // Bloc de code à exécuter si la condition est vraie
}

Si la condition est évaluée à true, le bloc de code à l’intérieur des accolades est exécuté. Sinon, il est ignoré. Voici un exemple concret :

int x = 10;
if (x > 5) {
    System.out.println("x est supérieur à 5");
}

L’instruction if-else

L’instruction if-else permet d’exécuter un bloc de code si une condition est vraie et un autre bloc de code si la condition est fausse. Voici sa syntaxe :

if (condition) {
    // Bloc de code à exécuter si la condition est vraie
} else {
    // Bloc de code à exécuter si la condition est fausse
}

Dans cet exemple, si la condition est vraie, le premier bloc de code est exécuté, sinon le second bloc est exécuté. Exemple :

int x = 3;
if (x % 2 == 0) {
    System.out.println("x est pair");
} else {
    System.out.println("x est impair");
}

L’instruction if-else if-else

L’instruction if-else if-else permet de tester plusieurs conditions en séquence. Elle évalue chaque condition dans l’ordre jusqu’à ce qu’une condition vraie soit trouvée. Voici sa syntaxe :

if (condition1) {
    // Bloc de code à exécuter si condition1 est vraie
} else if (condition2) {
    // Bloc de code à exécuter si condition2 est vraie
} else {
    // Bloc de code à exécuter si aucune des conditions précédentes n'est vraie
}

Cela permet de choisir parmi plusieurs alternatives. Voici un exemple :

int x = 10;
if (x > 0) {
    System.out.println("x est positif");
} else if (x < 0) {
    System.out.println("x est négatif");
} else {
    System.out.println("x est nul");
}

L’opérateur ternaire

L’opérateur ternaire (? :) est une forme condensée de l’instruction if-else. Il permet d’exprimer une condition de manière concise en une seule ligne. Voici sa syntaxe :

resultat = (condition) ? valeurSiVraie : valeurSiFausse;

Cet opérateur est très utile pour assigner des valeurs en fonction d’une condition. Exemple :

int x = 10;
String message = (x > 5) ? "x est supérieur à 5" : "x est inférieur ou égal à 5";
System.out.println(message);

L’instruction Switch

L’instruction switch permet de sélectionner parmi plusieurs alternatives en fonction de la valeur d’une expression. Voici un exemple de syntaxe :

int dayOfWeek = 3;
switch (dayOfWeek) {
    case 1:
        System.out.println("Lundi");
        break;
    case 2:
        System.out.println("Mardi");
        break;
    // ...
    default:
        System.out.println("Jour inconnu");
}

Dans cet exemple, le programme affiche le nom du jour de la semaine en fonction de la valeur de la variable dayOfWeek.

Le nouveau switch de Java SE 14

À partir de Java SE 14, une nouvelle syntaxe pour l’instruction switch a été introduite, appelée « switch expression » ou « enhanced switch ». Cette nouvelle syntaxe permet à l’instruction switch d’être utilisée comme une expression, ce qui signifie qu’elle peut retourner une valeur.

Voici un exemple de la nouvelle syntaxe de switch en Java SE 14 :

int day = 3;
String dayName = switch (day) {
    case 1 -> "Lundi";
    case 2 -> "Mardi";
    case 3 -> "Mercredi";
    case 4 -> "Jeudi";
    case 5 -> "Vendredi";
    case 6, 7 -> "Weekend";
    default -> "Jour inconnu";
};

System.out.println("Le jour est : " + dayName);

Dans cet exemple, la variable dayName est déclarée et initialisée avec une expression de switch. L’expression switch évalue la valeur de la variable day et retourne une chaîne correspondant au nom du jour de la semaine. Cette nouvelle syntaxe est plus concise et expressive que l’ancienne syntaxe de switch, et elle permet de réduire la quantité de code nécessaire pour gérer plusieurs cas.

Une autre caractéristique intéressante de cette nouvelle syntaxe est l’utilisation de l’opérateur -> pour spécifier le résultat à retourner pour chaque cas. Cela rend le code plus lisible et permet d’éviter l’encombrement visuel causé par l’ancienne syntaxe de switch avec les mots-clés case et break.

Il convient de noter que cette nouvelle syntaxe de switch en tant qu’expression permet également l’utilisation de blocs de code dans chaque cas, offrant ainsi une plus grande flexibilité pour le traitement des différents cas en utilisant L’opérateur yield.

L’opérateur yield

C’est une nouvelle fonctionnalité introduite dans Java SE 14 pour être utilisé avec les expressions de switch. Il est utilisé pour retourner une valeur à partir d’une expression de switch.

Dans le contexte des expressions de switch, yield est utilisé pour spécifier la valeur à retourner pour un cas donné. Cela permet d’éviter d’utiliser break pour terminer chaque cas, comme c’était le cas avec l’ancienne syntaxe de switch. Au lieu de cela, yield est utilisé pour déterminer explicitement la valeur à retourner pour le cas actuel.

Voici un exemple d’utilisation de yield dans une expression de switch :

int day = 3;
String dayName = switch (day) {
    case 1 -> "Lundi";
    case 2 -> "Mardi";
    case 3 -> {
        System.out.println("C'est le mercredi !");
        yield "Mercredi";
    }
    case 4 -> "Jeudi";
    default -> "Jour inconnu";
};

System.out.println("Le jour est : " + dayName);

Dans cet exemple, lorsque day est égal à 3, le programme affiche « C’est le mercredi ! » puis utilise yield pour retourner la chaîne « Mercredi » à partir de l’expression de switch.

L’utilisation de yield offre une syntaxe plus claire et plus concise pour retourner des valeurs à partir d’une expression de switch, tout en évitant les confusions potentielles liées à l’omission de break dans l’ancienne syntaxe de switch.