Esempio di istruzione condizionale (1)

In molte situazioni, l'esecuzione di uno o più passi di un programma dipende da certe condizioni (valori in input, stato della memoria,...).

Esempio: metodo withdraw della classe BankAccount:

public void withdraw(double amount) {
balance = balance - amount;
}

La seguente versione controlla se il saldo è sufficente: in caso contrario non fa niente.

public void withdraw(double amount)
{ if (amount <= balance)
balance = balance - amount;
}

Esempio di istruzione condizionale (2)

La prossima versione addebita una COMMISSIONE_SCOPERTO se il prelievo non è possibile:

public void withdraw(double amount)
{ if (amount <= balance)
      balance = balance - amount;
   else
      balance = balance - COMMISSIONE_SCOPERTO;
}

Istruzioni if e if-else: Sintassi

if ( <condizione> )
<istruzione-1>;

oppure

if ( <condizione> )
<istruzione-1>;
else <istruzione-2>;

dove:

<condizione> è un'espressione di tipo booleano
<istruzione-1> e <istruzione-2> possono essere:

istruzioni semplici

istruzione composte

blocchi di istruzioni

Istruzioni if e if-else: Significato

if ( <condizione> )
<istruzione-1>;
else <istruzione-2>;

L'istruzione if valuta la <condizione>

Se la valutazione ritorna il valore true esegue <istruzione-1>.
Se la valutazione ritorna il valore false esegue <istruzione-2> se presente, altrimenti passa al punto 2.

l'esecuzione passa 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.

Altri esempi (1)

**`if semplice`**
`if (i < 100)` `System.out.println ("minore di 100");`

**`if-else`**
`if (i < 100)` `System.out.println ("minore di 100");` `else` `System.out.println ("maggiore o uguale a 100");`

**`if-else`** con blocchi di istruzioni
`boolean min100;` `if (i < 100) {` `System.out.println ("minore di 100");` `min100 = true;` `} else {` `System.out.println ("maggiore o uguale a 100");` `min100 = false;` `}`

Altri esempi (2)

**`if-else`** annidati
`if (i < 100)` `if (i > 0)` `System.out.println ("minore di 100 e maggiore di zero");` `else` `System.out.println ("minore o uguale a zero");` `else` `if (i == 100)` `System.out.println ("uguale a 100");` `else` `System.out.println ("maggiore di 100");`

ScambioVariabili.java

Temperature.java

Comandi condizionali a più vie

Vogliamo scrivere un comando che assegna alla variabile int giorni il numero di giorni del mese memorizzato nella variabile int mese. Proviamo con comandi if-else.

Catena di **`if-else`** "naive"
`if (mese == 1)` `giorni = 31;` `else if (mese == 2)` `giorni = 29;` `else if (mese == 3)` `giorni = 31;` `else if (mese == 4)` `...`

Catena di **`if-else`** con condizioni composte
`if (mese == 2)` `giorni = 29;` `else if (mese == 4 \|\| mese == 6 \|\| mese == 9 \|\| mese == 11)` `giorni = 30;` `else` `giorni = 31;`

Codice compatto ma non molto leggibile. Quali sono i possibili valori di mese? Cosa succede se mese > 12?

Java, come molti altri linguaggi, fornisce un comando condizionale "a più vie" per questi casi.

Istruzione switch: Sintassi

switch ( <selettore> )
{
   case <valore1> : <istruzioni1>
   case <valore2> : <istruzioni2>
   ...
   default: <istruzioniN>
}

<selettore>è un'espressione di tipo char, byte, short, o int

<valoreX> è un'espressione costante dello stesso tipo del <selettore>. Ogni <valoreX> deve essere unico.

<istruzioniX> possono essere:

sequenze di istruzioni e dichiarazioni di variabili

blocchi 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.

Istruzione switch: Significato

switch ( <selettore> )
{
   case <valore1> : <istruzioni1>
   case <valore2> : <istruzioni2>
   ...
   default: <istruzioniN>
}

L'istruzione switch valuta il <selettore> ed esegue il blocco sequenzialmente

Se incontra dopo una etichetta case un <valoreY> uguale al risultato, esegue le <istruzioniY> corrispondenti e tutte le successive <istruzioniY+1>... <istruzioniN>.

Se non incontra un <valoreY> uguale alla valutazione ed è presente l'etichetta default esegue le <istruzioni1> corrispondenti.

Se non incontra un <valoreY> uguale alla valutazione e non è presente l'etichetta default passa al punto 3.

L'esecuzione passa all'istruzione successiva allo switch, dopo il blocco.

Anche le istruzioni switch possono essere annidate: <istruzioniX> può contenere uno switch.

Istruzione break nello switch

Per evitare che vengano valutate tutte le <istruzioniY+1>... <istruzioniN> successive ad un case soddisfatto si utilizza l'istruzione break.

Il break permette di trasferire l'esecuzione all'istruzione successiva al blocco dello switch; viene posto successivamente alle <istruzioniX>.

L'istruzione switch si utilizza quindi (solitamente) nella forma:

switch ( <selettore> )
{
   case <valore1> : <istruzioni1> break;
   case <valore2> : <istruzioni2> break;
   ...
   default: <istruzioniN> break;
}

Istruzione switch : Esempi

Giorni del mese con `switch`
`switch (mese) {` `case 9:` `case 4:` `case 6:` `case 11: giorni = 30; break;` `case 2: giorni = 28; break;` `default: giorni = 31; break;` `}`

Riconosce se un numero x compreso tra 1 e 10 è primo
`switch (x) {` `case 1: // va al successivo` `case 2: // va al successivo` `case 3: // va al successivo` `case 5: // va al successivo` `case 7:` `System.out.print (x);` `System.out.println (" è un numero primo");` `break;` `case 4: // va al successivo` `case 6: // va al successivo` `case 8: // va al successivo` `case 9: // va al successivo` `case 10:` `System.out.print (x);` `System.out.println (" non è un numero primo");` `break;` `default:` `System.out.println ("x è minore di 1 o maggiore di 10");` `break;` `}`

SceltaAPiuVie.java: Altro esempio con numeri

Espressioni condizionali

Sono una eredità di C e C++
Sintassi:

<condizione> ? <espressione1> : <espressione2>

Significato: E' 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 x = 0;
int y = (x != 0) ? 5/x : 5;

(x > 3)? x++ : x--; // prova.java:4: not a statement
// (x > 3)? x++ : x--;
// ^