Un approccio a Java: le variabili booleane

Ciao a tutti e bentornati!

La volta precedente, ho fatto un'introduzione alle strutture condizionali, definendo il loro funzionamento. Prima di poter dare qualche esempio pratico, è necessario chiarire in che modo ci è concesso operare con le condizioni. Per fare questo, è necessario approfondire leggermente il tipo dato boolean.

Tipo dati boolean

Prima di introdurre il tipo dato, è bene introdurre il concetto di dominio.

Con dominio di un tipo dato, intendiamo tutti i valori che una variabile di quel tipo dato può assumere. Nel nostro caso, il tipo dato boolean può assumere i valori true e false. Si può quindi dire che:

dominio(boolean) = {true, false}

La cosa che potrebbe suscitare dubbi è proprio l'utilizzo di questi valori. Vediamo meglio.

Per capire come usare un valore booleano, dobbiamo prima aver chiaro un concetto riguardante le condizioni. Nel momento in cui Java interpreta una condizione, la sostituisce nel codice con il valore booleano derivante dalla sua valutazione. Per esempio, immaginiamo di avere questo frammento di codice:

int a = 5;
if(a > 3){
	//fai qualcosa
}

La variabile a vale 5. La condizione viene valutata. Con questa configurazione di variabili, la condizione è vera. Possiamo quindi immaginare che il codice, dopo la valutazione, venga modificato in questo modo:

int a = 5;
if(true){
    //fai qualcosa
}

All'atto pratico, questo non è un passaggio che è evidente allo sviluppatore, ma ci introduce bene all'utilizzo del tipo booleano.

Dichiarazione e inizializzazione di una variabile boolean

Java mette a disposizione con la libreria standard il tipo dati booleano. 

Come tutte le variabili, ha una sua sintassi di dichiarazione.

boolean variabile;

Può anche essere inizializzata in questo modo:

variabile = true;

Ovviamente, se volessimo inizializzare la variabile con il valore false, basterebbe sostituire il true con il false, ottenendo un risultato come il seguente:

variabile = false;

Chiaramente, posso combinare insieme dichiarazione e inizializzazione in questo modo:

boolean variabile = false;

É bene spezzare una lancia a favore di Java. La messa a disposizione di valori booleani è comoda e rende il codice, a mio parere, più leggibile. Altri linguaggi, come il C per esempio, mettono a disposizione questo tipo dato solo per mezzo di altre librerie. Comodo il fatto di averlo a disposizione con la libreria standard.

Utilizzo di una variabile booleana

Dopo aver dichiarato e valorizzato la variabile booleana, giunge il fatidico momento dove è necessario utilizzarla. Vediamo come questo è possibile partendo da un esempio.

int a = 5;
int b = 4;
boolean variabileBooleana = (a + b) < 10;

Questo primo semplice esempio porta in evidenza il fatto che si possa valorizzare una variabile anche con il risultato della valutazione di una condizione anche non elementare. In questo caso, la condizione da valutare è (a+b)<10 che, con questa particolare configurazione di variabili, risulta essere vera. 

La variabile booleana conterrà quindi il valore true. Per verificarlo, è possibile stampare sul terminale la condizione attraverso una semplice System.out.println();.

Ipotizziamo ora di voler controllare mediante un if se la variabile booleana contiene il valore true. Lo possiamo fare mediante l'operatore di confronto ==. Scriveremo quindi:

int a = 5;
int b = 4;
boolean variabileBooleana = (a + b) < 10;
if(variabileBooleana == true){
    //fai qualcosa
}

In questa maniera, possiamo effettuare controlli con oggetto variabili booleane. Possiamo comportarci analogamente per valutare se il contenuto sia false. Scriveremo quindi: 

...
if(variabileBooleana == false){
  //fai qualcosa
}

La scrittura variabileBooleana == true risulta però essere inutilmente verbosa. Quello che vorremmo è trovare un modo per esprimere lo stesso concetto, ma in maniera più semplice e concisa.

Per fare questo, è necessario sapere che una scrittura del tipo

if(true){
    ....
}

è assolutamente inutile da scrivere in un programma, ma è assolutamente funzionante, infatti il blocco di istruzioni nell'if verrà sempre eseguito in questo caso. Ci si potrebbe chiedere il perchè di questa parentesi. Il perchè è abbastanza semplice giunti a questo punto. Nel momento in cui si fa un confronto con oggetto una variabile, al posto del nome simbolico, viene sostituito il valore contenuto in essa. 

Ma se viene sostituito il valore, un controllo del tipo variabileBooleana == true diventa true == true, che è inutilmente verboso. Ci si chiede quindi quale sia il metodo per poter rendere meno verbosa la scrittura. 

In modo molto semplice, si scrive un if come il seguente

if(variabileBooleana){
    ....
}

Si nota subito che, nel momento in cui il nome simbolico della variabile verrà sostituito con il suo valore, si otterrà un codice come quello mostrato poc'anzi, che abbiamo detto essere assolutamente funzionante. Ecco perchè quella scrittura rimane valida. Chiaramente, non capita praticamente mai di vederla scritta esplicitamente così nelle soluzioni a dei normali esercizi, dal momento in cui non influenzerebbe in alcuna maniera il normale flusso del programma.

Analogamente, ci si potrebbe domandare se esista una maniera di controllare se una variabile sia valorizzata con false. In questo momento, mi limiterò a dare la sintassi Java per poterlo fare. La spiegazione dettagliata è rimandata al prossimo articolo.

La sintassi è:

if(!variabileBooleana){
    ...
}

Questa scrittura si legge "if not variabileBooleana".

Come detto prima, al momento non è necessario capire il significato. Per capirlo è necessario introdurre gli operatori booleani, cosa che faremo in seguito.

Nota conclusiva

Un'ultima cosa importante da dire è che spesso si tende a bistrattare i valori booleani in favore di condizioni molto lunghe e complesse negli if. A mio parere, e ribadisco che è un mio parere personale dettato dalla mia esperienza, talvolta è preferibile creare una variabile booleana e valorizzarla con il valore dato dalla valutazione della condizione lunga e complessa.

L'idea è di avere un codice così:

boolean isValid = condizioneLungaEComplessa;
if(isValid){

}

Al posto di un codice così:

if(condizioneLungaEComplessa){

}

Ci si potrebbe chiedere perchè. Secondo me, si guadagna in leggibilità del codice. Questa cosa è vera se la variabile booleana ha un nome che permetta di capire quello che quella variabile rappresenta. 

La regola di dare dei nomi significativi alle variabili è una good practice sempre valida. Credo fortemente che sia meglio dare un nome leggermente più lungo ad una variabile in modo che sia significativo. Sottolineo il leggermente perchè l'estremo opposto è altrettanto brutto. Non è mai bello avere variabili con nomi lunghissimi. Al posto che guadagnare leggibilità, si perde. 

Anche per questa volta è tutto, vi invito a continuare a sperimentare  Alla prossima!