I cicli, in poche parole, servono per far ripetere un certo numero di volte una certa azione al programma. Per sapere quante volte l'azione deve essere ripetuta bisogna imporre delle condizioni. Queste condizioni sono espresse tramite controlli sul valore di alcune variabili che creiamo proprio a questo scopo.
Parlando di codice, i cicli possono essere specificati tramite l'istruzione for oppure tramite do...while.
Vi sarete subito chiesti perché due differenti istruzioni per fare la stessa cosa. La risposta è un po' tecnica: con for viene prima fatto il controllo e poi eventualmente viene eseguita l'operazione corrispondente, mentre con do...while viene eseguita l'operazione una volta, si controlla se le condizioni sono soddisfatte e se sono soddisfatte si continua, altrimenti no. Quindi in questo modo viene eseguita l'istruzione almeno una volta. Non preoccupatevi se subito non capite il bisogno di avere questo tipo di situazione (ovvero fare almeno una volta l'operazione, a prescindere dal risultato del test), perché a volte può servire.
Passiamo ora a vedere la sintassi di queste due istruzioni:
FOR
DO...WHILE
for (cond_iniz; cond_fine; modifica)
{
//Istruzioni da eseguire
}
do
{
//Istruzioni da eseguire }
while(condizione);
So che scritto così può essere un po' criptico, ma vediamo subito un paio di esempi per concretizzare quanto detto:
int i=0;
String numeri[ ] = new String[10];
for (i=0; i<10; i++)
{
numeri[i] = "OK! ";
}
Queste righe di codice dichiarano un array di stringhe con 10 elementi e tramite un ciclo for si riempie con stringhe che hanno valore "OK! "
Praticamente funziona così: si crea la variabile i inizializzata a zero. Se è minore di 10 si scrive la stringa "OK! " nella posizione dell'array con indice i. Successivamente si aumenta di uno i. Se la variabile è ancora minore di 10 si ripete l'operazione. Non appena i è maggiore o uguale a 10 il processo si interrompe. Se dopo questa istruzione ne inseriamo una che stampa il contenuto dell'array, lo vedremo pieno di stringhe "OK! ".
La stessa cosa può essere fatta con un ciclo do...while in questo modo:
String numeri[ ] = new String[10];
int i=0;
do
{
numeri[i] = "OK! ";
i++;
}
while(i<10);
A parte qualche piccolo cambiamento nel codice il risultato che si otterrebbe stampando il contenuto dell'array sarebbe lo stesso di quello ottenuto dopo il for.
Se però avessimo messo i=11 all'inizio e poi avessimo stampato il contenuto dell'array?
Il primo (quello con for) sarebbe stato vuoto (11>10 subito, quindi NON viene eseguita nessuna operazione), mentre con do...while l'operazione sarebe stata fatta almeno una volta e l'array sarebbe stato ugualmente vuoto, anzi ci sarebbe stato un errore perché non sarebbe esistita la posizione 11 nell'array. Ma se l'array fosse stato definito in questo modo
String numeri[ ] = new String[12];
dopo l'esecuzione del ciclo do...while l'array avrebbe contenuto la stringa "OK! " alla posizione 11.
Visto l'esempio pratico non è più tanto difficile, no?
Espressioni condizionali
Vi sarà capitato di pensare: "Se piove prendo l'ombrello". Avete appena espresso una condizione necessaria (deve piovere) per compiere una certa azione (prendere l'ombrello). Che ne dite allora di vedere in che modo sia possibile far fare ad un programma una scelta del genere (magari non prenderà proprio l'ombrello ma...).
Ecco come fare: il più semplice pezzettino di codice che possiate scrivere è questo:
if (i=0)
JOptionPane.showMessageDialog(null, "La variabile i vale zero");
Tralasciando il codice che genera l'azione che viene eseguita (che vedremo più in là), vediamo cosa succede.
Premesso che la variabile i deve essere già stata dichiarata e inizializzata, succede questo: se tale variabile è uguale a zero viene mandato un messaggio.
E se è diversa da zero? Semplice, non succede nulla. In questo caso quindi accade qualcosa solo per un determinato valore della variabile.
Se invece di una sola azione se ne volessero fare eseguire due o più, basta racchiuderle tra parentesi graffe (che come avrete capito servono per raggruppare blocchi di istruzioni).
Ad esempio se oltre a mandare un messaggio, si volesse cambiare il valore di i si sarebbe scritto:
if (i=0)
{
JOptionPane.showMessageDialog(null, "La variabile i vale zero");
i=-1;
}
Questo però ci impedisce di definire una operazione diciamo di "default" nel caso la condizione non sia verificata, condizione che sia diversa da un semplice "non far niente".
A questo proposito si introduce una nuova keyword: else.
Vediamo come funziona:
if(i=0)
{
JOptionPane.showMessageDialog(null,"La variabile i vale zero");
i=-1;
}
else
JOptionPane.showMessageDialog(null,"La variabile i NON vale zero");
i=1;
}
In questo caso (a parte il solito discorso fatto prima per i) la prima parte di codice è la stessa, mentre la seconda specifica che nel caso la variabile i sia diversa da zero (un qualsiasi altro valore), deve essere mandato un messaggio diverso e la variabile assume un nuovo valore. Personalmente ritengo che questo è particolarmente utile quando si effettuano dei test sul programma, del tipo se la variabile vale quanto aspettato continua l'esecuzione, altrimenti (else) manda un messaggio di errore.
E se vogliamo discriminare tra più di un valore specifico?
Niente di più facile: si usa else if e il gioco è fatto:
if(i=0)
{
JOptionPane.showMessageDialog(null,"La variabile i vale zero");
i=-1;
}
else if(i=1)
{
JOptionPane.showMessageDialog(null,"La variabile i vale uno");
i=-2;
}
else
{
JOptionPane.showMessageDialog(null,"La variabile i NON vale zero o uno");
i=-3;
}
In questo caso, se i vale zero si manda il primo messaggio, se vale uno il secondo messaggio, se ha un qualsiasi altro valore si manda il messaggio standard.
Notate che è possibile usare quante condizioni ci pare ed è possibile anche annidare degli if all'interno di altri if e inoltre le condizioni dell'if possono contenere operatori booleani. Ad esempio se volessimo far eseguire una certa azione solo se due variabili fossero entrambe zero bisognerebbe scrivere:
if ( (i=0)&&(m=0) )
{
//Set di istruzioni
}
oppure se almeno una delle due deve essere zero:
if ( (i=0)||(m=0) )
{
//Set di istruzioni
}
Come avete visto all'interno delle condizioni degli if si possono usare anche formule che usano le parentesi.
Per selezionare tra più valori possibili associati da una variabile si può anche usare l'istruzione switch. Il suo utilizzo è il seguente:
switch ( i )
{
case 0:
JOptionPane.showMessageDialog(null,"La variabile i vale zero");
break;
case 1:
JOptionPane.showMessageDialog(null,"La variabile i vale uno");
break;
default:
JOptionPane.showMessageDialog(null,"La variabile i NON vale zero o uno");
break;
}
Come avete visto nelle parentesi dopo switch ci va messa la variabile da controllare, mentre con case si elencano i valori che può assumere (da notare che i numeri si scrivono così come sono, i caratteri tra apici e le stringhe tra doppi apici).
Ora che siete a conoscenza del minimo indispensabile per mandare avanti una applicazione, il passo successivo è iniziare a fare la prima applet del tipo "Hello world!".