Istruzioni if e if-else
< istruzione1 >
}
oppure
< istruzione1 >
}
else {
< istruzione2 >
}
dove
< condizione > è un’espressione booleana
< istruzione1 > e < istruzione2 > possono essere:
– istruzioni semplici;
– istruzione composte;
– blocchi di istruzioni.
L’istruzione if valuta la < condizione >…
Se la valutazione ritorna il valore true esegue < istruzione1 >.
Se la valutazione ritorna il valore false esegue < istruzione2 > (se presente).
In ogni caso, l’esecuzione passa poi all’istruzione successiva al comando if.
Le istruzioni if possono essere annidate: in questo caso, per evitare ambiguità, ogni else si riferisce al primo if che lo precede.
In caso di annidamento, una corretta indentazione del codice e l’uso di parentesi graffe possono facilitare e disambiguare la lettura del programma.
Esempio if, con if-else annidato:
public class Giudizio1 {
public static void main(String[] args) {
Scanner varS = new Scanner(System.in);
System.out.println(“Immetti un voto:”);
int voto = varS.nextInt();
if ( voto>=18 && voto<=30 ) {
if ( voto>=24 ) {
System.out.println(“Il risultato e’ buono”);
}
}
else {
System.out.println(“Il risultato e’ sufficiente”);
}
}
}
Esempio: if-else, con if annidato:
public class Giudizio2 {
public static void main(String[] args) {
Scanner varS = new Scanner(System.in);
System.out.println(“Immetti un voto:”);
int voto = varS.nextInt();
if ( voto>=24 ) {
if ( voto<=30 ) {
System.out.println("Il risultato e' buono");
}
}
else {
if ( voto>=18 ) {
System.out.println(“Il risultato e’ sufficiente”);
}
}
}
}
Esercizio scambioVariabili:
public class ScambioVariabili {
public static void main (String [] args) {
Scanner varS = new Scanner(System.in);
System.out.print (“Dammi x: “);
int x = varS.nextInt();
System.out.print (“Dammi y: “);
int y = varS.nextInt();
System.out.println (“x = ” + x + “, y = ” + y);
// scambia il valore delle due variabili
// solo se x > y
if ( x > y ) {
// per scambiare i valori e’ necessaria una
// variabile di appoggio!
int temp = x;
x = y;
y = temp;
}
System.out.println (“x = ” + x + “, y = ” + y);
}
}
Comandi condizionali a più vie
Supponiamo di voler scrivere un comando che assegni alla variabile String giorno il nome del giorno lavorativo corrispondente al day-esimo giorno della settimana, oppure la stringa “Week end”.
Scanner varS = new Scanner(System.in);
String giorno;
String day = varS.nextLine();
if (day == 1) {
giorno = “Monday”;
}
else if (day == 2) {
giorno = “Tuesday”;
}
else if (day == 3) {
giorno = “Wednesday”;
}
else if (day == 4) {
giorno = “Thursday”;
}
else if (day == 5) {
giorno = “Friday”;
}
else if (day == 6 || day == 7) {
giorno = “Week-end”;
}
else {
giorno = null;
}
…
Istruzione switch
case < valore1 > : < istruzioni1 >
case < valore2 > : < istruzioni2 >
…
default: < istruzioniN >
}
< selettore > è un’espressione che fornisce un risultato di tipo char, byte, short, int, o di un tipo enumerativo.
< valore_ > è un’espressione costante dello stesso tipo del
< istruzioni_ > può essere o una sequenza di istruzioni e dichiarazioni di variabili o un blocco di istruzioni.
default può essere presente una sola volta.
Quello che segue la parte (< selettore >) deve essere un blocco, che può essere vuoto o iniziare con case o default.
1. L’istruzione switch valuta il < selettore > ed esegue il blocco sequenzialmente.
2. Scorrendo il blocco possono verificarsi tre casi:
– Se incontra un’etichetta case seguita da un < valore_ > uguale al risultato del < selettore >, esegue le < istruzioni_ > corrispondenti e tutte le successive < istruzioni_+1 >…< istruzioniN >;
– Se invece nessuno dei < valore_ > è uguale alla valutazione del < selettore > ma è presente l’etichetta default, allora esegue le < istruzioniN > corrispondenti;
– Se invece nessuno dei < valore_ > è uguale alla valutazione del < selettore > e non è presente neppure l’etichetta default, allora passa al punto 3.
3. L’esecuzione passa infine all’istruzione immediatamente successiva al blocco dello switch.
Anche le istruzioni switch possono essere annidate.
Per evitare che vengano valutate tutte le < istruzioni_+1 >…< istruzioniN > successive a quelle di un case soddisfatto si utilizza l’istruzione break.
Il break permette di trasferire l’esecuzione all’istruzione immediatamente successiva al blocco dello switch. Tipicamente break viene posto come ultima istruzione di ogni case (ovvero dopo ogni < istruzioni_ >).
L’istruzione switch si utilizza quindi (solitamente) nella forma:
case < valore1 > : < istruzioni1 > break;
case < valore2 > : < istruzioni2 > break;
…
default: < istruzioniN > break;
}
Espressioni condizionali
Vediamo anche le espressioni condizionali che, nel caso particolare del calcolo di un valore, possono offrire una notazione più compatta rispetto all’if-else.
Sintassi:
Significato: è una espressione, non un comando.
– se la < condizione > vale true, il risultato è il valore di < espressione1 >.
– se la < condizione > vale false, il risultato è il valore di < espressione2 >.
Esempio:
int y = (x != 0) ? 5/x : 5;
//dato che la condizione è falsa, y assumerà il valore della seconda espressione, ovvero 5.