Expressions conditionnelles
Pour écrire des programmes utiles, nous avons presque toujours besoin de vérifier des conditions et de modifier le comportement du programme en conséquence. Les instructions conditionnelles nous donnent cette capacité.
Expression conditionnelle If-Else
La forme la plus simple est l'instruction if-else :
Exemple :
Écrivez le code suivant dans le fichier /home/labex/project/ifelseTest.java :
public class ifelseTest{
public static void main(String[] args){
int x = 1;
if (x > 0) {
System.out.println("x is positive");
}
else{
System.out.println("x is non-positive");
}
}
}
Sortie :
Exécutez le fichier ifelseTest.java en utilisant les commandes suivantes dans le terminal :
javac /home/labex/project/ifelseTest.java
java ifelseTest
Voyez la sortie :
x is positive
L'expression entre parenthèses est appelée condition. Si elle est vraie, alors les instructions entre accolades suivant if sont exécutées. Si la condition n'est pas vraie, les instructions entre accolades suivant else sont exécutées. Si aucun else n'est prévu et que la condition if est fausse, les instructions, s'il y en a, suivant l'instruction if-else sont exécutées. La condition peut contenir n'importe lequel des opérateurs de comparaison, également appelés opérateurs relationnels :
Exemple :
if (x == y){ } // x equals y
if (x!= y){ } // x is not equal to y
if (x > y) { } // x is greater than y
if (x < y) { } // x is less than y
if (x >= y){ } // x is greater than or equal to y
if (x <= y){ } // x is less than or equal to y
Bien que ces opérations vous soient probablement familières, la syntaxe utilisée par Java est un peu différente des symboles mathématiques tels que =, ≠ et ≤. Une erreur courante est d'utiliser un seul signe égal (=) au lieu de deux signes égaux (==). N'oubliez pas que = est l'opérateur d'affectation et == est un opérateur de comparaison. De plus, il n'y a pas de =< ou =>.
Les deux côtés d'un opérateur conditionnel doivent être du même type. Vous ne pouvez comparer que des entiers avec des entiers et des nombres à virgule flottante avec des nombres à virgule flottante. Les opérateurs == et != fonctionnent avec les String, mais ils ne font pas ce que vous attendez. De plus, les autres opérateurs relationnels ne fonctionnent pas sur les chaînes de caractères du tout.
Un exemple : Si le reste de la division de x par 2 est 0, alors nous savons que x est pair et ce code affiche un message à cet effet. Si la condition est fausse, la deuxième instruction d'affichage est exécutée. Étant donné que la condition doit être vraie ou fausse, exactement l'une des alternatives sera exécutée. Si vous pensez que vous voudrez vérifier la parité (pair ou impair) des nombres souvent, vous voudrez peut-être « encapsuler » ce code dans une méthode, comme suit :
Exemple :
Écrivez le code suivant dans le fichier /home/labex/project/conditionTest.java :
public class conditionTest
{
public static void printParity(int x) {
if (x%2 == 0) {
System.out.println(x + " is even");
} else {
System.out.println(x + " is odd");
}
}
public static void main(String[] args){
printParity(17);
printParity(18);
}
}
Sortie :
Exécutez le fichier conditionTest.java en utilisant les commandes suivantes dans le terminal :
javac /home/labex/project/conditionTest.java
java conditionTest
Voyez la sortie :
17 is odd
18 is even
Maintenant, vous avez une méthode nommée printParity qui affichera un message approprié pour tout entier que vous souhaitez fournir. Dans main, vous appelez cette méthode. N'oubliez jamais que, lorsque vous appelez une méthode, vous n'avez pas à déclarer les types des arguments que vous fournissez. Java peut déterminer de quel type ils sont. Vous devriez résister à la tentation d'écrire des choses comme : printParity(int 3). De plus, vous pouvez également imbriquer une condition dans une autre.
Exemple :
Écrivez le code suivant dans le fichier /home/labex/project/nestedConditionTest.java :
public class nestedConditionTest{
public static void main(String[] args){
int x = 0; // you can try x = 1, x = -1
if (x == 0) {
System.out.println("x is zero");
}
else {
if (x > 0) {
System.out.println("x is positive");
}
else {
System.out.println("x is negative");
}
}
}
}
Sortie :
Exécutez le fichier nestedConditionTest.java en utilisant les commandes suivantes dans le terminal :
javac /home/labex/project/nestedConditionTest.java
java nestedConditionTest
Voyez la sortie :
x is zero
Il y a maintenant une condition externe qui contient deux branches. La première branche contient une simple instruction d'affichage, mais la deuxième branche contient une autre instruction conditionnelle qui a elle-même deux branches. Les deux branches sont des instructions d'affichage, mais elles auraient pu être des instructions conditionnelles également.
L'indentation aide à rendre la structure jolie et compréhensible, mais néanmoins les conditions imbriquées deviennent rapidement difficiles à lire. Évitez-les si vous le pouvez. D'un autre côté, ce type de structure imbriquée est courant, et nous allons le voir à nouveau. Donc, mieux vaut vous y habituer.
Expression conditionnelle Switch-Case
L'instruction switch-case est une autre expression conditionnelle. La syntaxe de l'instruction switch-case est la suivante :
Exemple :
// value type can be byte, short, int, char, String, but long type is not correct.
switch (variable or an value expression)
{
// case value must be a constant value
case value1:
// code
;
case value2:
// code
;
default:
// code
;
}
Exemple :
Écrivez le code suivant dans le fichier /home/labex/project/switchTest.java :
public class switchTest
{
public static void main(String[] args){
// you can change i = 2, then try again
int i = 2;
switch(i)
{
case 1:
System.out.println(1);
break;
case 2:
System.out.println(2);
// if no break expression, sometimes you'll get a confusing answer.
// you can try deleting the break expression and see what happens.
break;
// if none of the above matches, execute the default statements
default:
System.out.println("default");
break;
}
}
}
Sortie :
Exécutez le fichier switchTest.java en utilisant les commandes suivantes dans le terminal :
javac /home/labex/project/switchTest.java
java switchTest
Voyez la sortie :
2
