Operatori logici

"Ciao, Amico!"

"Ora faremo una piccola lezione sugli operatori logici."

"Quali operatori logici conosci?"

— OR (||), AND (&&), NOT(!)

"Sì. Bel lavoro. E ti ricordi come funzionano?"

"SÌ."

"OR restituisce vero quando almeno un operando è vero."

"AND restituisce vero quando entrambi gli operandi sono veri."

"NON cambia vero in falso e falso in vero."

"Esatto. E in che ordine vengono valutati gli operatori in questa espressione?"

boolean a = true;
boolean b = false;
boolean c = true;

boolean result = a && b || !c && b || !a;

"È tutto molto semplice."

"Prima, NOT (!), poi AND (&&), e poi OR (||) alla fine."

Se aggiungiamo le parentesi otteniamo:

boolean a = true;
boolean b = false;
boolean c = true;

boolean result = (a && b) || ((!c) && b) || (!a);

"È tutto corretto, ben fatto. E qual è il risultato?"

— 1) (a && b) == (vero && falso) == falso

2) ((!c) && b) == (falso && falso) == falso

3) (!a) == falso

4) falso || falso || falso == falso

"Il risultato è falso."

"Sembra che tu conosca perfettamente l'argomento. Poi ti svelerò un paio di piccoli segreti."

"In primo luogo, le espressioni logiche vengono valutate da sinistra a destra."

"In secondo luogo, qui viene utilizzata la valutazione di cortocircuito (i calcoli vengono eseguiti solo se necessario). Se il risultato finale è già noto dalla valutazione di parte dell'espressione, il resto dell'espressione non viene valutato."

boolean result = (true && false) || (true && true) || (true && false);

"Questa espressione è divisa in tre parti separate dall'operatore OR (||)."

"Se almeno una parte è vera, allora la risposta è vera e nient'altro deve essere considerato. Di conseguenza, l'espressione viene valutata in questo modo:"

1)  Valuta la prima parte:  (vero && falso) == falso

2)  Valuta la seconda parte:  (vero && vero) == vero

3) Non valutiamo la terza parte, poiché è già chiaro che la risposta sarà vera .

"Questo approccio è anche chiamato valutazione pigra".

"OK. E cosa c'è di così speciale?"

"Niente, fino a quando non inizi a chiamare i metodi all'interno dell'espressione. Se una parte dell'espressione viene saltata, i metodi nella parte saltata non verranno chiamati."

"Ma questo approccio è diventato molto comune. Ecco perché:"

Job job = null;

if (job != null && job.isDone())
{
…
}

"Se job è null quando viene valutata l'espressione, allora la chiamata job.isDone() non avverrà!"

"In effetti, la prima parte dell'espressione è falsa, seguita da AND (&&). Quindi, l'intera espressione sarà ritenuta falsa e la seconda parte non sarà necessaria."

"Esattamente. È una buona tecnica, vero?"

"Sì."