Accueil > Programmer avec Java > Structures de contrôle >
Un programme peut prendre des décisions et, ainsi, devenir plus intelligent. Comme tout dans un ordinateur, ces décisions sont à base binaire, c’est-à-dire qu’elles sont basées sur des conditions qui sont soit vraies, soit fausses. Dans cette leçon, nous allons apprendre à écrire des conditions en Java. Nous allons aussi apprendre à utiliser des opérateurs logiques pour combiner des conditions.
Les conditions sont utilisées pour sélectionner une branche d’instructions parmi un choix de branches. Elles sont aussi utilisées pour déterminer si une boucle doit se répéter ou se terminer. Il y a d’autres utilisations, comme décider si une méthode se termine ou non, mais toutes ces applications seront vues dans des leçons séparées.
true ou false. On peut penser à des conditions comme une façon formelle de poser une question oui/non à un ordinateur.booleantrue ou false. On peut utiliser ce type de valeur dans des variables qui indiquent l’état de différentes choses dans le programme.==, !=, <, <=, >, >=..equals pour les String et .hasNextInt pour un Scanner.&& (ET), || (OU) et ! (PAS).À la fin de cette leçon vous devrez être en mesure de :
==, !=, <, <=, > et >=.&&, || et !.boolean)L’expression booléenne la plus simple est une valeur littérale booléenne : soit true (vrai), soit false (faux). On peut utiliser ces valeurs littérales directement ou assignées à des variables, par exemple, boolean repeat = true;.
Une variable booléenne est pratique pour représenter l’état de quelque chose, par exemples : repeat ci-dessus qui peut indiqur s’il faut répéter une action ou non ou boolean isOn = true; qui peut représenter si une fonctionnalité est activée ou non. Ce type d’usage des valeurs booléennes s’appelle un drapeau. On peut regarder son état dans des conditions ou modifier son état dans le code, par exemple isOn = false; pour éteindre l’ampoule.
Un autre type d’expression booléenne est une opération de comparaison. Une opération de comparaison compare deux valeurs et retourne une valeur booléenne. Par exemple, x == y est une expression de comparaison qui retourne true si x est égal à y et false sinon. Les opérateurs de comparaison sont :
== (égal),!= (différent/pas égal),< (inférieur),<= (inférieur ou égal),> (supérieur)>= (supérieur ou égal).Voici quelques exemples à tester dans une session jshell :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
5 == 5; // notez : comparer l'égalité utilise deux "=", soit "=="
5 != 5;
5 < 5;
5 <= 5;
5 > 5;
5 >= 5;
int x = 4; // notez : assigner utilise un seul "="
int y = 5;
x == y;
x != y;
x < y;
x <= y;
x > y;
x >= y;
false. L’opérateur de comparaison représente “plus grand ou égale à”
false. On évalue les parenthèses en premier, donnant 9 < 8 qui est faux.
Il y a aussi des méthodes de comparaison, généralement utilisées pour comparer différents objets du même type. On doit utiliser une méthode de comparaison pour comparer des objets de type String. Par exemple, "abc".equals("abc") retourne true et "abc".equals("def") retourne false. Il y a quatre méthodes de comparaison pour les String :
equals (égal), par exemple "abc".equals("abc")equalsIgnoreCase (égal, sans tenir compte de la casse), par exemple "abc".equalsIgnoreCase("ABC") retourne truecompareTo (inférieur, égal ou supérieur), qui retourne une valeur négative si la première valeur est inférieur, zéro si les deux valeurs sont égales et une valeur positive si la première valeur est supérieure. Par exemple "abc".compareTo("def") retourne une valeur négative (-3).compareToIgnoreCase (inférieur, égal ou supérieur, sans tenir compte de la casse)La raison pourquoi la comparaison directe d’objets comme des String ne fonctionne pas est expliquée dans le cours ICS4U. C’est en lien avec la représentation de ces valeurs en mémoire versus la façon dont les valeurs primitives (comme des
int) sont représentées en mémoire.
Voici quelques exemples de comparaisons de String à tester dans une session jshell :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
"abc".equals("abc");
"abc".equals("def");
"abc".equals("ABC");
"abc".equalsIgnoreCase("ABC");
"abc".compareTo("def"); // donne un chiffre
"abc".compareTo("def") == 0; // tester l'égalité (donne un booléen)
"abc".compareTo("def") < 0; // tester si "abc" est inférieur à "def"
"abc".compareTo("def") > 0; // tester si "abc" est supérieur à "def"
// La comparaison se fait à la base de la valeur Unicode des caractères
// et les majuscules sont AVANT les minuscules dans la table Unicode
"abc".compareTo("ABC"); // donne un chiffre positif
"abc".compareTo("ABC") > 0; // tester la supériorité (donne un booléen)
"abc".compareToIgnoreCase("ABC"); // donne un chiffre
"abc".compareToIgnoreCase("ABC") == 0; // tester l'égalité (donne un booléen)
Notez que pour utiliser les méthodes compareTo comme conditions, il faut utiliser le chiffre retourné par la méthode dans une expression de comparaison afin d’obtenir un résultat true ou false.
C’est 'a'! Sa valeur ASCII de 97 est 32 de plus que la valeur ASCII de 'A' (65). Et oui, les minuscules sont “plus grandes que” les majuscules dans le tableau ASCII.
false. Les minuscules et les majuscules sont des caractères distinctes pour un ordinateur.
true. La méthode spéciale .equalsIgnoreCase ignore les différences de case des lettres.
On peut combiner le résultat d’expressions booléennes avec les opérateurs logiques ET (&&) et OU (||). On peut aussi inverser le résultat d’une expression booléenne en le précédant avec l’opérateur PAS (!).
Comme avec d’autres opérateurs, il y a un ordre de priorité. L’opérateur PAS a la priorité la plus élevée, suivi de ET et, finalement, OU. On peut utiliser des parenthèses pour changer l’ordre d’évaluation.
Voici quelques exemples à tester dans une session jshell :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// exemples pour voir les opérateurs
true && true; // ET
true && false;
false && true;
false && false;
false || true; // OU
!true; // PAS
!false;
!true && true;
!(true && true); // effet des parenthèses
// exemples plus réalistes
int x = 5;
(x > 0) && (x < 10); // entre 0 et 10
(x < 0) || (x > 10); // en dehors de 0 à 10
// déterminer si je mange au restaurant utilisant deux variables booléennes
amHungry && restaurantOpen;
// l'équivalent de != pour la méthode de comparaison .equals()
!"abc".equals("def");
false. ! est l’opérateur “non” ou “inverse”, donnant toujours le contraire de la valeur qui le suit.
true. L’opérateur || signifie “ou”. Seulement une valeur dans la chaîne doit être vraie pour que tout soit vrai.||) l’évaluation progresse simplement de gauche à droite donnant : (false) || false || true ensuite (false) || true et finalement (true).false. L’opérateur && signifie “et” et donne vrai seulement si les deux valeurs sont vraies.
Voici l’ordre d’évaluation de l’expression :
!false devient true&& précède ||, on continue avec le premier && : (true) && false qui donne false&& : (false) && true qui donne encore false|| (ou) : (false) || false donne aussi false.Répondre aux questions insérées dans les notes après les exemples.
Écrire des conditions appropriées pour donner true dans les situations suivantes. Utilisez des noms de variables appropriées si la valeur n’est pas fournie explicitement.
"a" (String).'a' (char). Indice 1 : on peut obtenir le premier caractère d’une réponse (p. ex.: pick) avec pick.charAt(0).Indice 2 : un char est un type primitif comme int.! dans l’expression.21.1.Codinbat est un site qui offre des problèmes de logique à résoudre avec Java ou Python. C’est donc excellent pour pratiquer les conditions.
prefs sous “Teacher Share” ajoutez mon adresse courriel. Vous pouvez le trouver dans le Classroom ou dans votre Gmail de l’école dans la liste des contacts. Je pourrai alors voir vos progrès.Astuces pour travailler dans CodingBat :
return dans votre code.Go après avoir écrit votre code. Plusieurs cas de tests seront exécutés pour vérifier si votre solution est correcte et vous verrez exactement quels cas ont été réussis et lesquels ont échoués. Vous pouvez tester votre solution autant de fois que vous voulez.C’est fort possible que vous ayez de la difficulté avec plusieurs de ces casse-têtes. C’est normal! Si vous avez de la difficulté, essayez de comprendre la solution fournie et de la réécrire vous-même. Le but est de vous familiariser avec les conditions et les opérateurs logiques afin que vous puissiez les utiliser dans des contextes de votre choix pas dans le contexte de problèmes de logique.
&&, ||, !), en plus de quelques opérations mathématiques ou sur les String à l’occasion. Les problèmes à tenter sont dans la section Warmup-1 :
Math.abs)substring)charAt et substring)% pour trouver le reste de la division par 3 ou 5)length et substring)Math.min et Math.max)length, substring et equals)% pour trouver le reste de la division par 10)Certaines solutions officielles à ces problèmes utilisent la sélection avec
ifetelsepour résoudre les problèmes, mais si le problème est dans la liste ci-dessus, vous êtes capable de remplacer cet embranchement en utilisant les opérateurs logiques ET&&et OU||pour produire une seule expression équivalente.