I valori di verità e il tipo boolean

Il tipo di dato boolean (dal matematico George Boole) comprende due soli valori: true e false. Ciò nonostante, si tratta di un tipo di dati molto importante nella programmazione, perché permette di dirigere il flusso di esecuzione dei comandi, come vedremo meglio in seguito.

Oltre alle costanti true e false, sono di tipo boolean espressioni più complesse costruite con operatori booleani e/o relazionali (o di confronto).

Si noti che in molti linguaggi (anche in C e C++) non esiste un tipo di dati corrispondente: come valori di verità si usano gli interi con opportune convenzioni (ad esempio, il valore 0 rappresenta false e qualsiasi valore diverso da 0 rappresenta true).

Gli operatori booleani in Java

**Operatori booleani (o logici) in Java**
(in ordine decrescente di precedenza)
`!`	`&&`	`^`	`\|\|`

**Tabella di verità**
		`NOT`	`AND`	`XOR`	`OR`
`x`	`y`	`!x`	`x && y`	`x ^ y`	`x \|\| y`
`false`	`false`	`true`	`false`	`false`	`false`
`true`	`false`	`false`	`false`	`true`	`true`
`false`	`true`	`true`	`false`	`true`	`true`
`true`	`true`	`false`	`true`	`false`	`true`

Qual è il valore di (true ^ true && false || !true) ?

Suggerimento: data la precedenza degli operatori la formula viene letta come
( (true ^ (true && false )) || (!true) )

Note:

Gli operatori not, and, or dovrebbero esservi familiari
L'operatore xor (or esclusivo) potete ricordarlo più facilmente come come l'operatore di confronto diverso da

Gli operatori di confronto

Gli operatori relazionali o di confronto in Java sono i seguenti:

> >= < <= == !=

Tutti questi operatori possono essere applicati a valori numerici di qualsiasi tipo (int, double, char...), con il significato atteso (ad esempio: il confronto di caratteri 'c' < 'f' restituisce true)

Gli operatori di uguaglianza e diseguaglianza (== e !=) possono essere applicati a qualunque tipo di dati Java, in particolare ai booleani e a tipi di dato non primitivi che vedremo in seguito e per i quali discuteremo il significato di tali operatori.

Gli operatori di confronto hanno precedenza più alta rispetto alle operazioni su booleani (e più bassa rispetto agli operatori aritmetici, che comunque operano su tipi diversi).

Si noti che come eredità del C, si usa == per l'uguaglianza invece di = (simbolo di assegnamento).

`int x = 10;` `int y = 20;` `boolean b = (x < y);`	`b` vale `true`
`boolean b1 = ((x >= y) == b);`	`b1` vale `false`
`double r = Math.sqrt(2);` *`boolean b2 = (2.0 == r r);`**	`b2` vale `false`!!

Attenzione: come si vede nell'ultimo esempio, in generale non ha senso confrontare due valori double con == o con != a causa degli errori di approssimazione: il confronto di (dis)uguaglianza sarebbe meglio farlo a meno di un valore fissato, piccolo a piacere.

Operatori lazy

Gli operatori && e || sono operatori lazy (pigri) o short-cut: valutano il secondo argomento solo se è necessario.

c && d d viene valutato solo se c vale true

c || d d viene valutato solo se c vale false

a!=0 && b/a > 100 si legge (a!=0) && ((b/a) > 100)
se a==0, allora ((b/a) > 100) non viene valutato e la condizione vale false

Uso di espressioni booleane: Istruzioni if-else

In molti algoritmi, l'esecuzione di uno o più passi può dipendere da certe condizioni (valori in input, stato della memoria,...). Per controllare l'esecuzione di questi passi si può usare l'istruzione condizionale if-else.

Vediamone alcuni esempi (la studieremo in dettaglio più avanti).

if (x == 0) System.out.println("x vale zero");      //  la stringa viene stampata solo se x e' uguale      //  a zero cioe' se la condizione e' vera
if (x > y) System.out.println("x e' maggiore di y");   else   System.out.println("y e' maggiore di o uguale a x");      //  il ramo 'else' viene eseguito solo      //  se la condizione e' falsa
if (x > y) System.out.println("x e' maggiore di y");   else if (x < y) System.out.println("y e' maggiore di x");        else  System.out.println("x e y sono uguali");

Errori tipici

Un'espressione booleana esprime già, per sua natura, un valore di verità: non c'è bisogno di confrontarla con true per stabilire se è vera e con false per stabilire se è falsa.

Invece di scrivere if ( <bool-expr> == true ) ...
o di scrivere if ( <bool-expr> != false ) ...
dovete scrivere semplicemente
if ( <bool-expr> ) ...
Invece di scrivere if ( <bool-expr> == false ) ...
o di scrivere if ( <bool-expr> != true ) ...
dovete scrivere semplicemente
if ( ! <bool-expr> ) ...