« Salutations, Amigo ! J'étais tellement emporté par la résolution de problèmes de logique que je ne t'ai pas remarqué. En voici un pour toi : si les crocodiles volent, alors la neige est blanche. Il y a un crocodile volant. Quelle est la conclusion ?
"Euh... Donc nous concluons que la neige est blanche ?"
"Excellent ! Vous avez réussi le test d'initiation. Vous êtes prêt à maîtriser le sujet suivant. Il s'appelle les "opérateurs logiques". . Nous avons juste besoin d'ajuster vos paramètres pour qu'ils correspondent au langage Java."
"La logique booléenne ? On m'a récemment parlé du type booléen..."
"Oui, il y a un lien direct ici. Les expressions booléennes ne peuvent être que vraies ou fausses. Et il se trouve que ce type de logique concerne uniquement les expressions qui sont vraies ou fausses, et les combinaisons de ces expressions. Par exemple, l'expression 18 < 25 est toujours vrai et 7 < 5 est toujours faux. L'expression (i < 10) dépend de la valeur de i. Et si l'expression est évaluée, par exemple, à vrai, alors nous pouvons demander au programme de faire quelque chose.
"Ahh, je comprends. Les expressions booléennes nous permettent non seulement de tirer des conclusions logiques, mais aussi de créer des fourches dans les programmes."
"Exactement. L'essentiel est d'apprendre à les écrire. Par exemple, en Java, vous ne pouvez pas simplement écrire l'expression 18 < age <65
. Ce serait syntaxiquement incorrect et le programme ne se compilerait pas.
"Mais vous pouvez l'écrire comme ceci :
(18 < age) AND (age < 65)
Bien sûr, nous n'utilisons pas le mot ANGLAIS AND
. Au lieu de cela, vous avez besoin d'un opérateur booléen . C'est-à-dire que "ET" est représenté différemment.
"Il existe trois opérateurs logiques en Java : AND
(&&), OR
(||), NOT
(!).
La bonne nouvelle est que vous pouvez utiliser des parenthèses pour construire des expressions logiques de n'importe quelle complexité.
La mauvaise nouvelle est que les développeurs Java ont décidé d'utiliser la notation du langage C au lieu des mots and
, or
et not
.
Regarde l'écran:
Opérateur logique | Attente | Réalité |
---|---|---|
AND (∧) |
and |
&& |
OR (∨) |
or |
|| |
NOT (¬) |
not |
! |
"En fait, ce n'est pas si mal... Assez compact. Je les ai presque mémorisés."
"Eh bien, c'est merveilleux. Voici quelques exemples d'utilisation d'opérateurs logiques en Java :
Expression | Interprétation | Explication |
---|---|---|
(0 < a) && (a < 100) |
(0 < a) and (a < 100) |
(0 < a) AND (a < 100) |
(!a) && (!b) |
(not a) and (not b) |
(NOT a) AND (NOT b) |
!(!a || !b) |
not((not a) or (not b)) |
NOT((NOT a) OR (NOT b)) |
Exemples d'utilisation d'opérateurs de comparaison et de variables booléennes
"N'oubliez pas, Amigo, partout où vous pouvez écrire une expression logique, vous pouvez écrire une variable logique."
« Comment ça ? »
"Je veux dire que vous pouvez écrire des expressions logiques de différentes manières. Par exemple :
Code | Explication |
---|---|
|
Si la valeur de l'âge est comprise entre 18 et 65 , la phrase "Vous pouvez travailler" s'affiche. |
|
Nous avons créé une isYoung variable et y avons déplacé la première partie de l'expression. Nous avons simplement remplacé age >= 18 par age < 18 . |
|
Nous avons créé une variable isOld et y avons déplacé la deuxième partie de l'expression. De plus, age <= 65 a été remplacé par age > 65 . |
"Ces trois exemples sont équivalents. Ce n'est que dans le deuxième exemple que nous avons déplacé une partie de l'expression de l'instruction if
dans une variable booléenne distincte ( isYoung
). Dans le troisième exemple, nous avons déplacé la deuxième partie de l'expression dans une deuxième variable ( isOld
). Au fait, la valeur par défaut d'une variable booléenne est false
."
"Je m'en souviendrai. J'espère."
Arithmétique logique
« Maintenant, passons brièvement en revue les opérations logiques. Elles obéissent à des règles très simples et logiques (comment pourrait-il en être autrement !).
"D'abord, voyons comment OR
fonctionne l'opérateur. Il est également connu sous le nom de disjonction||
ou .
Expression | Résultat |
---|---|
true || true |
true |
true || false |
true |
false || true |
true |
false || false |
false |
"Pouvez-vous déduire maintenant quel est le résultat de l'expression a || b
basée sur la table?"
"Je vois!" La valeur d'une expression est true
si au moins un terme de l'expression est true
. Si les deux sont false
, alors le résultat est false
.
"C'est exact. Puisque vous êtes si intelligent, jetez un autre coup d'œil à la table et imaginez que c'est false
0 et true
1. Quand vous le regardez de cette façon, le ||
comportement de l'opérateur vous rappelle-t-il quelque chose de l'arithmétique ordinaire ?"
"Euh... Bon, c'est un peu comme l'addition... Mais quand on fait l'addition, 1 + 1 n'est pas égal à 1."
"Il y a un sens dans lequel c'est égal si nous ne travaillons qu'avec 0 et 1. Mais ne vous embêtez pas avec ça pour le moment. L'important est que vous ayez remarqué la similitude entre l'opération ||
et l'addition. Cela signifie que vous ne Ne soyez pas surpris par le fait que cette opération est souvent appelée « addition logique ».
"J'ai compris."
"Maintenant AND
, l'opérateur de conjonction&&
, alias alias , entre en scène.
Expression | Résultat |
---|---|
true && true |
true |
true && false |
false |
false && true |
false |
false && false |
false |
"Si je comprends bien, le résultat d'une expression n'est true
que si les deux valeurs qui composent l'expression sont true
. Sinon, c'est toujours false
."
« Bravo, Amigo ! Tu absorbe tout ça comme une éponge. Tu vois une autre ressemblance avec l'arithmétique ?
"Multiplication!"
"Exactement. Nous avons donc ici une 'multiplication logique'".
"Ensuite, nous regardons l' NOT
opérateur, alias !
, alias l' inverse logique .
Expression | Résultat |
---|---|
!true |
false |
!false |
true |
"Eh bien, tout est assez simple ici. L'opérateur passe true
à false
et vice versa."
"Exactement. Voici quelques expressions utiles pour vous :"
Expression | Résultat |
---|---|
m && !m |
false |
m || !m |
true |
!(a && b) |
!a || !b |
!(a || b) |
!a && !b |
GO TO FULL VERSION