Ed eccoci qui in un nuovo articolo, dove continueremo l’argomento Java!
Nello scorso articolo hai potuto vedere le variabili booleane, il loro utilizzo. Hai potuto anche approfondire gli operatori relazionali (o condizionali) e hai potuto anche vedere diverse forme sintattiche della struttura IF.
Ora continuiamo ad andare avanti.
Innanzi tutto voglio mostrarti una curiosità che è molto importante:
È possibile mettere delle condizioni all’interno di altre condizioni. Ti faccio un esempio:
[java]
Scanner sc = new Scanner(System.in);
int menu = 0;
System.out.println("Premi 1 per calcolare un’addizione");
// altre voci nel menu
menu = sc.nextInt();
if (menu == 1){
int nm = 0, dm = 0;
// nm = numeratore e dm = denominatore
System.out.println("Inserisci il numeratore e il denominatore"
+ " nell’ordine segnato");
// ho usato questa sintassi per poter andare a capo.
// Le stringhe non possono essere spezzate e quindi bisogna concatenarne
//una ad un’altra
System.out.println("Attenzione! Il valore del numeratore non può essere"
+ " inferiore di 0");
nm = sc.nextInt();
dm = sc.nextInt();
if (nm < 0){
System.out.println("Perfavore reinserisci il valore del numeratore");
nm = sc.nextInt();
}
//In questa condizione c’è un problema, ma lo vedremo più avanti
//Quando andremo a vedere la terza forma fondamentale della programmazione
System.out.println("Il risultato dell’addizione e’ -> " + nm + dm);
// non ho salvato il risultato in nessuna variabile
}
[/java]
Come possiamo ben notare è possibile inserire una condizione all’interno di un’altra condizione.
Inoltre con questo programma hai imparato molte piccole cose nuove utili, spiegate nei commenti.
Bene, ora direi che sai bene la struttura if. Ora passiamo ad un’altro sistema sempre incluso nel pacchetto della forma condizionale. Questo sistema si chiama switch.
Lo switch è un keyword speciale che hanno tutti i linguaggi C/C++ based e che ha la funzione di semplificare il programmatore nella scrittura del codice.
Abbiamo visto in questo articolo (la prima parte della forma condizionale) l’if, scrivendo una calcolatrice con interfaccia grafica a riga di comando in cui permettesse all’utente di scegliere il calcolo desiderato e quindi di poter fare l’operazione e ottenere un risultato. Come hai potuto notare, si è dovuto ricorrere a diverse condizioni per creare la calcolatrice. Ogni volta che si scrive una condizione con l’if, si deve inserire un blocco di istruzioni delimitato dalle parentesi graffe appartenente a quella determinata condizione.
Il problema è che più si aumentano il numero delle condizioni e più è necessario inserire blocchi separati di istruzioni, righe di codice che rendono il tutto poco comprensibile a primo impatto e se si devono effettuare delle modifiche si è un po’ in difficoltà.
Ecco perché esiste lo switch. Esiste per abbreviare la sintassi di una serie di condizioni ove ce ne sono tante. Certo che se si ha a che fare con una condizione o due, allora si ricorre all’if, è inutile ricorrere allo switch. Però se si ha a che fare con tante condizioni, all’ora applicare lo switch sarebbe molto comodo.
Con questo nuovo sistema, si introducono 2 nuove keyword, più naturalmente la keyword switch, che andremo a vedere ora.
[java]
import java.util.Scanner;
public class Esercizi {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
int menu = 0;
System.out.println("Premi 1 per calcolare un’addizione");
System.out.println("Premi 2 per calcolare una sottrazione");
System.out.println("Premi 3 per calcolare una moltiplicazione");
System.out.println("Premi 4 per calcolare una divisione");
menu = sc.nextInt();
switch(menu){
case 1:
int num = 0, den = 0, ris = 0;
/* Le variabili non si possono aggiungere prima della
* parola case e quindi le ho messe nel primo case (primo caso).
* Poi vengono letti anche dagli altri case, perché il blocco di
* istruzioni è il medesimo.
*/
System.out.println("Inserisci il numeratore e il denominatore");
num = sc.nextInt();
den = sc.nextInt();
ris = num + den; // ho fatto la somma al di fuori del metodo stampa
// Ora non devo fare altro che stampare il valore della variabile ris
System.out.println("Il risultato e’ -> " + ris);
break;
case 2:
System.out.println("Inserisci il numeratore e il denominatore"
+ " da sottrarre");
num = sc.nextInt();
den = sc.nextInt();
ris = num – den;
System.out.println("Il risultato e’ ->" + ris);
break;
case 3:
System.out.println("Inserisci il numeratore e il denominatore da moltiplicare");
num = sc.nextInt();
den = sc.nextInt();
ris = num * den;
System.out.println("Il risultato e’ -> " + ris);
break;
case 4:
System.out.println("Inserisci il numeratore e il denominatore da dividere");
// lo so che nel caso della divisione si chiamerebbero divisore e dividendo, ma
// per semplificare li chiamiamo così. Stessa cosa nelle altre operazioni
num = sc.nextInt();
den = sc.nextInt();
ris = num / den;
System.out.println("Il risultato e’ -> " + ris);
break;
}
}
[/java]
Allora le keyword sono case e break.
case vuol dire nel caso in cui. Il valore che c’è dopo è la condizione.
Ora spiego meglio.
All’interno delle parentesi tonde dello switch viene passata una variabile in questo caso la variabile menu.
case vuol dire: nel caso in cui il valore della condizione è 1 (case 1), esegui queste istruzioni.
Nel caso il valore della variabile della condizione fosse 2 (case 2) esegui queste altre istruzioni.
Ecc…
Break vuol dire interrompere. Quando le istruzioni contenute in un case finiscono, il break serve per uscire dall’esecuzione del blocco dello switch e passare alle prossime istruzioni del programma.
Se non si mettesse il break, la JVM eseguirebbe tutti gli altri case che seguono quello eseguito e non è che sia una cosa ottimale e non sarebbe più una condizionale, ma una forma sequenziale.
Quindi va usato il break.
I due punti dopo il numero della condizione specificata dal case serve per dire al compilatore che li seguiranno delle istruzioni da essere eseguite.
Con lo switch non si può applicare nessun operatore relazionale e nessuna forma sintattica presente nella struttura if, quindi non si può usare && o ||, ma si possono aggiungere prevalentemente soltanto variabili singole, come nell’esempio qui sopra.
Attenzione: lo switch non supporta al meglio condizioni decimali (con variabili float e double). Ne il compilatore, ne l’IDE Eclipse segnaleranno un errore se si fa uso di condizioni decimali, perché in effetti non è un errore, ma il programma creato potrebbe andare in crash.
Nell’if abbiamo visto che una condizione se è verificata esegue un blocco di istruzioni; se non è verificata, si esegue (ove è presente) il blocco di istruzioni dell’else, oppure il programma prosegue nella sua esecuzione uscendo quindi dalla condizione.
Nello switch una condizione non è verificata soltanto da un vero o falso, ma è verificata se corrisponde a uno dei tanti case presenti.
Quindi non ha molto senso usare gli operatori relazionali, come maggiore uguale, l’operatore di uguaglianza ecc.. Infatti non è possibile usarli perché il compilatore darebbe errore.
[java]
package f96;
import java.util.Scanner;
public class Esercizi{
public static void main(String[] args){
int menu = 33;
switch(menu == 33){
// Qui il compilatore ha dato errore
// Non è possibile usare un operatore relazionale
}
}
}
[/java]
Come avrai potuto ben notare, la condizione dello switch molto spesso è composta da una sola variabile e poi ci sono vari case che sono le varie condizioni da verificare. Come hai visto nell’esempio qui sopra, la condizione all’interno della parentesi tonda era la variabile menu e poi i vari case permettevano di controllare se all’interno della variabile menu ci fosse memorizzato il numero 1, 2 ecc… e ad ognuno di questi valori corrispondeva a una specifica serie di istruzioni da eseguire da parte della JVM.
Stessa cosa per le forme sintattiche come || o &&. Non avrebbe senso usarli e quindi il compilatore darà errore se li si pongono all’interno della condizione.
Come avrai potuto notare, lo switch è una struttura molto semplice, che però permette di fare grandi cose.
Con questo io ti saluto e ci rivediamo al prossimo articolo.
