In questo articolo vedremo i costrutti condizionali if- else if -else e Switch, che ci permetteranno durante l’esecuzione del programma di eseguire delle scelte. Già questi costrutti ci permetteranno di cominciare a fare qualche divertente esercizietto quindi buono studio!
Mentre programmiamo, spesso abbiamo bisogno se una (o più) condizione si verifica di eseguire istruzioni diverse.
Per esempio, potremmo chiedere ad un utente di inserire la sua età e nel caso questa sia inferiore ai 18 anni, vietargli l’accesso ad alcune funzioni del nostro programma.
In generale, è possibile decidere di effettuare un operazione al verificarsi o meno di una condizione usando il costrutto condizionale if.
Vediamo un esempio:
public static void main(String[] args)
{
int eta = 15;
if (eta < 18)
{
System.out.println("Funzione vietata: hai meno di 18 anni");
}
}
Quello che fà questo semplice programma, è vedere se la variabile eta ha un numero minore di 18. Se lo è, stamperà:
Funzione vietata: hai meno di 18 anni
Altrimenti, stamperà:
Accesso consentito: hai più di 18 anni
If ( dall' inglese se) prende tra le due parentesi tonde che lo seguono una condizione booleana, ovvero un'espressione che abbia come risultato vero o falso.
Nel caso la condizione contenuta risulti vera, verrà eseguito il blocco di istruzioni contenuto all'interno delle parentesi graffe.
Volendo poi, possiamo aggiungere un blocco else (altrimenti) che ci permette di specificare le istruzioni da eseguire in caso la condizione risulti falsa:
public static void main(String[] args)
{
int eta = 15;
if (eta < 18)
{
System.out.println("Funzione vietata: hai meno di 18 anni");
}
else
{
System.out.println("Accesso consentito: hai più di 18 anni");
}
}
Esercizio
[blockquote]Stampare il valore assoluto di un numero. [/blockquote]
Il valore assoluto vuol dire che se è negativo, verrà stampato lo stesso valore ma cambiato di segno. Se è positivo, verrà stampato e basta.
[toggle title="Soluzione"]
public static void main(String[] args)
{
int numero = 10;
if (numero < 0)
{
System.out.print(-numero);
}
else
{
System.out.println(numero);
}
}
[/toggle]
Altra sintassi accettata
Volendo, è possibile specificare il nostro if su una sola riga. Per esempio:
if(condizione) System.out.print("Vero");
else System.out.print("Falso");
Questo è utile nel caso in cui dobbiamo eseguire solo un'istruzione a seguito dell' if ma ricordatevi sempre che scritto in questo modo, l'else si riferisce all' ultimo if scritto.
Vediamo un'altro esempio:
if (Math.random() < 0.5) System.out.println("Hai vinto");
else System.out.println("Hai perso");
Il metodo statico random della classe Math, ci permette di avere un numero causale compreso fra 0 ed 1. Per avere un numero maggiore, ci basta moltiplicare per il limite che vogliamo (es: se vogliamo un numero fra 0 e 5, mettiamo Math.random()*5).
Accenni di metodi: Esercizio guidato
[blockquote]Creare un metodo che ritorna true se la stringa data in input è di lunghezza è pari (Sapendo che la lunghezza di una stringa si prende con nomeVariabileStringa.length() e che il simbolo % è l'operatore modulo) altrimenti false.[/blockquote]
Per farlo, creiamo la nostra classe "Prova".
Dopodichè, cominciamo a scrivere il nostro metodo lunghezzaPari (di cui abbiamo parlato nel precedente articolo in teoria).
Questo metodo, avrà come input una stringa s, e avrà come output un booleano.
Cominciamo a scrivere il metodo quindi:
public class Prova
{
public boolean lunghezzaStringa(String stringa)
{
}
}
Le parole chiavi che lo precedono, sono:
- public: il livello di visibilità del metodo (ne parleremo meglio nei prossimi articoli)
- boolean: il tipo di oggetto che ritorna il nostro metodo
- lunghezzaStringa: il nome del metodo
- String stringa: l'input del nostro metodo
Se vi ricordate come scriviamo il metodo main, metodo che viene richiamato automaticamente quando vogliamo testare una classe, segue esattamente questa sintassi.
Realizziamo adesso il nostro metodo:
public class Prova
{
public boolean lunghezzaStringa(String stringa)
{
if (stringa.length()%2 == 0) //E' pari
{
return true;
}
else
{
return false;
}
}
}
Con la parola chiave return, diamo il valore di ritorno che deve corrispondere al tipo dichiarato col metodo.
Se volessimo testarlo?
Prima di tutto ci serve il main: sotto a questo metodo, sempre nella stessa classe, scriviamo:
public static void main(String[] args)
{
}
Poi, dobbiamo crearci un'oggetto Prova, e richiamare il suo metodo (tramite Prova.nomeMetodo) su una stringa che dobbiamo passare in input.
Per creare un oggetto di tipo Prova, utilizziamo la parola chiave new Oggetto();.
Vediamo nel dettaglio:
public static void main(String[] args)
{
Prova s = new Prova();
String stringa = "La mia stringa di esempio.";
if(s.lunghezzaStringa(stringa)) System.out.print("E' pari");
else System.out.print ("E' dispari");
}
Se hai capito tutto ciò che abbiamo fatto in questo "accenno" alla oop in pratica... sei a buon punto! Ma non temere, più pratica fai e meglio capisci come funziona tutto 🙂
Per sicurezza, quì trovi la soluzione completa:
[toggle title="Soluzione"]
public class Prova
{
public boolean lunghezzaStringa(String stringa)
{
if (stringa.length()%2 == 0) //E' pari
{
return true;
}
else
{
return false;
}
}
public static void main(String[] args)
{
Prova s = new Prova();
String stringa = "La mia stringa di esempio.";
if(s.lunghezzaStringa(stringa)) System.out.print("E' pari");
else System.out.print ("E' dispari");
}
}
[/toggle]
E se... E se... Oppure se...
Ma nel caso avessimo bisogno di altre condizioni? In questo caso ci viene in aiuto il costrutto else if (oppure se) che si usa in questo modo:
if(condizione1) System.out.print("Condizione1 verificata.");
else if(condizione2) System.out.print("Condizione2 verificata.");
else if(condizione3) System.out.print("Condizione3 verificata.");
else System.out.print("Nessuna delle condizione si è verificata!.");
Nel caso condizione1 non si verifichi, java proverà a vedere se condizione2 è vera. Se non lo è continuerà fino all'else, altrimenti si fermerà e stamperà solo l'istruzione contenuta nel primo blocco che verifica la sua condizione.
Switch-Case
Nel caso abbiamo un' espressione intera come condizione (o, da java 7 - l'ultimo-, una stringa) possiamo utilizzare il blocco switch-case che ha questa struttura:
int s = 2;
switch(s)
{
case 0 : System.out.println("Caso: 0");
break;
case 1 : System.out.println("Caso: 1");
break;
case 2 : System.out.println("Caso: 2");
break;
default: System.out.println("Nessun caso :(");
break;
}
Questo praticamente dice: Preso il contenuto della variabile s, se è 0 fai questo, se è 1 fai questo se è 2 fai quest'altro. Se non è nessuno dei 3 casi, allora esegui quello di default.
Il comando break ci permette di uscire dal blocco, perchè un'altra cosa utile è la possibilità di eseguire da un punto in poi tutte le istruzioni. Per esempio, se volessimo eseguire il caso 0 e il caso 1 insieme, ci basterebbe togliere il primo break per eseguire le istruzione contenute nei due casi. Questo però, vuol dire che:
se si verifica il caso 0, anche le istruzioni del caso 1 verranno eseguite.
se si verifica il caso 1, solo le istruzioni del caso 1 verranno eseguite.
Esercizio
[blockquote]Creare un metodo che prende in input due interi e una stringa. In base al contenuto della stringa, (che conterrà il comando) eseguirà le 4 operazioni di base con i due interi: addizione, sottrazione, moltiplicazione, divisione.[/blockquote]
Testare la classe usando il metodo main.
[toggle title="Soluzione"]
Creiamo un metodo "calcolatrice" (per comodità uso sempre la stessa classe "Prova") con visibilità public, tipo di ritorno int, due interi e una stringa come input.
Prepariamo il nostro risultato e lo impostiamo con zero, ed utilizziamo un blocco switch-case per eseguire le operazioni e cambiare il valore di "risultato". Nel caso risultato non sia conosciuto, verrà stampato un errore ma il metodo ritornerà comunque zero.
public class Prova
{
public int calcolatrice(int intero1, int intero2, String stringa)
{
int risultato = 0; //Inizializzo a zero il risultato
switch(stringa)
{
case "addizione": risultato = intero1+intero2;
break;
case "sottrazione": risultato = intero1-intero2;
break;
case "moltiplicazione": risultato = intero1*intero2;
break;
case "divisione": risultato = intero1/intero2;
break;
default: System.err.println("Comando sconosciuto"); //System.err ci permette di stampare a video un errore
break;
}
return risultato; //Ritorno il risultato
}
public static void main(String[] args)
{
System.out.print(new Prova().calcolatrice(2, 2, "divisione"));
}
}
[/toggle]
Nel prossimo articolo vedremo i costrutti iterativi: il for e il while.
