En développement, les programmes ont besoin de conditions. C'est-à-dire que la machine va exécuter un morceau de code si une condition est respectée. C'est un élément clé de la programmation et elle est prise en charge de différentes façon en Java.
Le mot clé if permet la création de condition. Sa syntaxe est la suivante :
if (/* expression booléenne */) {
// corps du if
}
Si le corps du if (le bloc de code à exécuter) ne comporte qu'une seule instruction, il est possible de ne pas mettre les accolades et d'écrire simplement
if (/* expression booléenne */)
// une seule instruction
voire même
if (/* expression booléenne */) // une seule instruction
C'est assez rare de le voir écrit comme ça mais ça pourrait vous servir de le savoir.
Ainsi, on peut évaluer des expressions booléennes, et suivant leur résultat le programme réagira d'une façon appropriée.
int variable = 95;
if (variable > 90) {
IO.println("La variable vaut plus de 90");
}
Le mot clé else est à utiliser en association avec le if. Il permet de lancer du code si l'expression donnée dans le if est évaluée à false.
int variable = 95;
if (variable == 90) {
IO.println("La variable vaut 90");
} else {
IO.println("La variable ne vaut pas 90");
}
Il est possible de tester plusieurs conditions avec des enchainements de if et else if :
int variable = -1;
if (variable == 90) {
IO.println("La variable vaut 90");
} else if (variable < 0) {
IO.println("La valeur de la variable est négative");
} else {
IO.println("La variable ne vaut pas 90 et n'est pas négative");
}
Le programme exécutera le premier bloc de code dont la condition est vraie et n'exécutera pas les autres.
Le bloc else ne sera exécuté que si aucune des conditions au dessus n'est vérifiée. Il est à voir comme le choix par défaut si aucune condition n'est vérifiée, ça permet d'avoir des comportements par défaut dans le cas où le programme doit gérer des cas particuliers.
ATTENTION, l'ordre des condition est important car si plusieurs expressions sont true, seule la première sera exécutée et toutes les autres seront ignorées.
Le if et ses compères sont des instructions et pas des expressions, ils ne renvoient pas de valeurs. Il n'est donc pas possible d'avoir quelque chose comme int a = if (...)
.
En plus du if, il existe un autre moyen de gérer des conditions dans notre code avec les blocs switch. Ils sont assez différents et leur usage est à la préférence du développeurs dans certains cas. Le switch a quelques particularités que je vais énoncer mais d'abord, regardons à quoi il ressemble :
int variable = 80;
switch (variable) {
case 10 -> {
IO.println("variable vaut 10");
}
case 20, 30 -> {
IO.println("variable vaut 20 ou 30");
}
default -> {
IO.println("variable ne vaut ni 10, ni 20, ni 30");
}
}
Exactement comme pour le if, il a le droit à une syntaxe simplifiée quand les blocs de code ne comprennent qu'une seule ligne en retirant les accolades :
int variable = 80;
switch (variable) {
case 10 -> IO.println("variable vaut 10");
case 20, 30 -> IO.println("variable vaut 20 ou 30");
default -> IO.println("variable ne vaut ni 10, ni 20, ni 30");
}
Ici il n'est pas tout à fait question de conditions mais d'égalités. On va créer un bloc case pour chaque cas à gérer selon la valeur de notre variable et un bloc default pour gérer les autres cas. On ne peut donc pas avoir de case pour gérer si la valeur est inférieur ou supérieur et on ne peut pas non plus combiner les conditions avec des && (et) ou des || (ou) logiques. On peut cependant gérer plusieurs valeurs en les séparant par des virgules avec un seul case.
La syntaxe avec la flèche -> est assez récente (introduite dans Java 12) mais il existe une dernière syntaxe du switch qui ne doit plus être utilisée aujourd'hui. C'est une vieille syntaxe qui date de la création de Java et qui est inspirée du langage C.
Je vais vous la montrer et vous l'expliquer car vous serez amenés à la rencontrer sur internet :
int variable = 80;
switch (variable) {
case 10:
IO.println("variable vaut 10");
break; // break ?
case 20:
case 30:
IO.println("variable vaut 20 ou 30");
break; // encore break ?
default:
IO.println("variable ne vaut ni 10, ni 20, ni 30");
break; // ENCORE break ???
}
Cette syntaxe pose des problèmes car comme vous l'avez remarqué, elle comporte une ligne break à presque chaque case (sauf 20). La raison à ça est que sans la présence de ce break, les blocs des case plus bas seront exécutés même si leur condition n'est pas vérifiée.
Par exemple, le code
int variable = 20;
switch (variable) {
case 10:
IO.println("variable vaut 10");
case 20:
IO.println("variable vaut 20");
default:
IO.println("variable ne vaut ni 10, ni 20");
}
va m'afficher le cas case 20 et le cas default (ce qui est incorrect).
Cette syntaxe est trompeuse car elle ne permet pas d'utiliser des accolades comme nous en avons l'habitude, et elle utilise deux-points : au lieu de la flèche -> pour indiquer le début du bloc de code à exécuter et break pour indiquer la fin de ce bloc de code.
De nombreux développeurs peuvent faire une erreur d'inattention et oublier un break quelque part, ce qui provoquerait un mauvais comportement du programme et donc un bug. Pour cette raison, la nouvelle syntaxe du switch a été introduite et doit désormais être favorisée.
Il reste encore quelques particularités sur le switch (vous allez voir, il reserve encore de belles surprises que nous découvrirons dans un usage plus avancé). Parmi ces particularités, contrairement au if il est capable renvoyer une valeur ! Ce qui peut en faire une expression et pas une instruction ! Par contre, il nécessite désormais un point-virgule ; à la fin de son bloc de code. Il ne faut pas l'oublier ! (Note : Ce n'est pas le cas si le switch n'est pas utilisé comme expression)
int variable = 80;
String resultat = switch (variable) {
case 10 -> {
IO.println("variable vaut 10");
yield "texte 1";
}
case 20, 30 -> {
IO.println("variable vaut 20 ou 30");
yield "texte 2";
}
default -> {
IO.println("variable ne vaut ni 10, ni 20, ni 30");
yield "texte 3";
}
}; // coucou le point-virgule !
IO.println("resultat = " + resultat);
À la ligne 3, je déclare une variable et je l'initialise avec la valeur de retour du switch. Selon le cas, le mot clé yield va me renvoyer le bon texte dans resultat. Comme la valeur de variable est 80, le cas default sera exécuté et mon resultat vaudra "texte 3" !
Si on exécute ce programme en le mettant dans un main, on obtiendra dans la console :
variable ne vaut ni 10, ni 20, ni 30
resultat = texte 3
Cette fonctionnalité est assez récente donc vous ne la trouverez peut-être pas souvent dans du vieux code, mais à l'avenir je l'utiliserai quand ce sera nécessaire dans la suite du cours donc retenez la.
Passons au plat de résistance, les boucles !