"Saluti, Amigo! Ero così portato a risolvere problemi di logica che non mi sono accorto che sei entrato. Eccone uno per te: se i coccodrilli volano, allora la neve è bianca. C'è un coccodrillo che vola. Qual è la conclusione?"
"Ehm... Quindi concludiamo che la neve è bianca?"
"Eccellente! Hai superato il test di iniziazione. Sei pronto per padroneggiare l'argomento successivo. Si chiama 'operatori logici'. E inizieremo con la logica booleana. Istintivamente, lo sai già. Sei un robot, dopo tutto . Dobbiamo solo modificare le tue impostazioni in modo che corrispondano al linguaggio Java."
"Logica booleana? Recentemente mi è stato detto del tipo booleano..."
"Sì, qui c'è una connessione diretta. Le espressioni booleane possono essere solo vere o false. E si dà il caso che questo tipo di logica riguardi tutte le espressioni vere o false e le combinazioni di tali espressioni. Ad esempio, l'espressione 18 < 25 è sempre vero e 7 < 5 è sempre falso. L'espressione (i < 10) dipende dal valore di i. E se l'espressione restituisce, ad esempio, true, allora possiamo chiedere al programma di fare qualcosa."
"Ahh, ho capito. Le espressioni booleane ci permettono non solo di trarre conclusioni logiche, ma anche di creare fork nei programmi."
"Esattamente. L'importante è imparare a scriverli. Ad esempio, in Java non puoi semplicemente andare a scrivere l'espressione 18 < age <65
. Questo sarebbe sintatticamente errato e il programma non verrà compilato.
"Ma puoi scriverlo così:
(18 < age) AND (age < 65)
Naturalmente, in realtà non usiamo la parola INGLESE AND
. Invece, hai bisogno di un operatore booleano . Cioè, "AND" è rappresentato in modo diverso.
"Ci sono tre operatori logici in Java: AND
(&&), OR
(||), NOT
(!).
La buona notizia è che puoi usare le parentesi per costruire espressioni logiche di qualsiasi complessità.
La cattiva notizia è che gli sviluppatori Java hanno deciso di utilizzare la notazione del linguaggio C invece delle parole and
, or
e not
.
Guarda lo schermo:
Operatore logico | Aspettativa | La realtà |
---|---|---|
AND (∧) |
and |
&& |
OR (∨) |
or |
|| |
NOT (¬) |
not |
! |
"In realtà non è poi così male... Abbastanza compatto. Li ho quasi imparati a memoria."
"Bene, è meraviglioso. Ecco alcuni esempi di utilizzo di operatori logici in Java:
Espressione | Interpretazione | Spiegazione |
---|---|---|
(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)) |
Esempi di utilizzo di operatori di confronto e variabili booleane
"Ricorda, Amigo, ovunque tu possa scrivere un'espressione logica, puoi scrivere una variabile logica."
"Com'è quello?"
"Voglio dire che puoi scrivere espressioni logiche in diversi modi. Ad esempio:
Codice | Spiegazione |
---|---|
|
Se il valore dell'età è compreso tra 18 e 65 , viene visualizzata la frase "Puoi lavorare". |
|
Abbiamo creato una isYoung variabile e vi abbiamo spostato la prima parte dell'espressione. Abbiamo semplicemente sostituito age >= 18 con age < 18 . |
|
Abbiamo creato una variabile isOld e vi abbiamo spostato la seconda parte dell'espressione. Inoltre, age <= 65 è stato sostituito da age > 65 . |
"Questi tre esempi sono equivalenti. Solo nel secondo esempio abbiamo spostato parte dell'espressione dall'istruzione if
in una variabile booleana separata ( isYoung
). Nel terzo esempio, abbiamo spostato la seconda parte dell'espressione in una seconda variabile ( isOld
). A proposito, il valore predefinito di una variabile booleana è false
."
"Lo ricorderò. Spero."
Aritmetica logica
"Ora esaminiamo brevemente le operazioni logiche. Obbediscono a regole molto semplici e logiche (come potrebbe essere altrimenti!).
"Per prima cosa, vediamo come OR
funziona l'operatore. È noto anche come ||
o disgiunzione .
Espressione | Risultato |
---|---|
true || true |
true |
true || false |
true |
false || true |
true |
false || false |
false |
"Puoi dedurre ora qual è il risultato dell'espressione a || b
basata sulla tabella?"
"Vedo!" Il valore di un'espressione è true
se almeno un termine nell'espressione è true
. Se entrambi lo sono false
, il risultato è false
.
"Esatto. Dato che sei così intelligente, dai un'altra occhiata alla tabella e immagina che false
sia 0 e true
sia 1. Quando la guardi in questo modo, il ||
comportamento dell'operatore ti ricorda qualcosa dell'aritmetica ordinaria?"
"Ehm... beh, è un po' come l'addizione... ma quando fai l'addizione, 1 + 1 non fa 1."
"C'è un senso in cui è uguale se lavoriamo solo con 0 e 1. Ma non preoccuparti di questo ora. L'importante è che tu abbia notato la somiglianza tra l'operazione e l'addizione. Questo significa che ||
non Non essere sorpreso dal fatto che questa operazione sia spesso chiamata 'addizione logica'.
"Fatto."
"Ora l' AND
operatore &&
di congiunzione entra in scena.
Espressione | Risultato |
---|---|
true && true |
true |
true && false |
false |
false && true |
false |
false && false |
false |
"A quanto ho capito, il risultato di un'espressione è true
solo se entrambi i valori che compongono l'espressione sono true
. Altrimenti, è sempre false
."
"Ben fatto, Amigo! Stai assorbendo tutto questo come una spugna. Vedi un'altra somiglianza con l'aritmetica?"
"Moltiplicazione!"
"Esattamente. Quindi qui abbiamo una 'moltiplicazione logica'".
"Ora guardiamo all'operatore NOT
, noto anche !
come l' inverso logico .
Espressione | Risultato |
---|---|
!true |
false |
!false |
true |
"Bene, qui è tutto abbastanza semplice. L'operatore cambia true
in false
e viceversa."
"Esattamente. Ecco alcune espressioni utili per te:"
Espressione | Risultato |
---|---|
m && !m |
false |
m || !m |
true |
!(a && b) |
!a || !b |
!(a || b) |
!a && !b |
GO TO FULL VERSION