I nostri primissimi programmi erano una sequenza di istruzioni eseguite una dopo l'altra. Niente forchette. Questo include HelloWorld, che mostra un saluto. Include calcoli aritmetici. Dopo i nostri primi programmi, abbiamo imparato come fare il branching, cioè come fare in modo che un programma esegua azioni diverse a seconda di condizioni specifiche. Ecco il codice per il controllo di un impianto di riscaldamento e condizionamento centralizzato:
if (tempRoom>tempComfort)
airConditionerOn();
if (tempRoom<tempComfort)
heaterOn();
Fai il passo successivo. Nella vita di tutti i giorni, eseguiamo spesso azioni ripetitive uniformi, ad esempio sbucciare le mele per una torta. Questo affascinante processo può essere descritto come:
Se ci sono mele nella ciotola, eseguiamo i passaggi da 1.1 a 1.4:
1.1. Prendi una mela
1.2. Sbucciatela e tagliatela a fette
1.3. Disporre le fette di mela nella crosta di torta in una teglia
1.4. Ritorna al passaggio 1.
Diciamo che hai dieci mele, due mani e un coltello. Nella vita reale, sbucci in sequenza l'intera dozzina, seguendo lo stesso algoritmo per ogni mela. Ma come facciamo a fare in modo che un programma esegua un'azione ripetitiva per ogni mela?
Ci leghiamo al numero di mele, ma se non ne abbiamo abbastanza, alcuni dei comandi verrebbero eseguiti senza un "carico utile" (e potremmo tagliarci mentre proviamo a sbucciare una mela inesistente).
Se ci sono più mele che comandi da sbucciare, allora alcune mele rimarranno non sbucciate.
Tale codice è difficile da leggere. Ha molte ripetizioni ed è difficile da modificare.
I cicli sono istruzioni che consentono di eseguire ripetutamente azioni
Il ciclo while di Java funzionerà bene nel nostro caso. Questo costrutto mette più azioni in una struttura concisa e comprensibile. Usando un ciclo while , un algoritmo di taglio della mela per una torta potrebbe apparire così in Java:
while (numberOfApplesInBowl > 0) {
apple = bowl.grabNextApple();
arrangeInPie(apple.peel().slice());
numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
}
System.out.println("The apples for the pie have been processed.");
Sintassi dei comandi
La prima variante dell'istruzione while è così:
while (Boolean expression) {
// Loop body — the statement(s) that are repeatedly executed
}
Ecco una spiegazione dettagliata di ciò che accade quando questo codice viene eseguito:
Valutiamo l'espressione booleana che si trova tra parentesi dopo la parola chiave while .
Se l'espressione booleana restituisce true, vengono eseguite le istruzioni nel corpo del ciclo . Dopo l'esecuzione dell'ultima istruzione nel corpo del ciclo, andiamo al passaggio 1
Se l'espressione booleana restituisce false, saltiamo alla prima istruzione dopo il ciclo while .
Loop con una precondizione
Poiché valutiamo sempre l'espressione booleana (la condizione per entrare nel ciclo) prima di eseguire il corpo del ciclo, questa forma del ciclo while è spesso chiamata ciclo con precondizione . Costruiamo una tabella delle prime dieci potenze di un numero:
public static void main(String[] args) {
int base = 3; // The number that will be exponentiated
int result = 1; // The result of exponentiation
int exponent = 1; // The initial exponent
while (exponent <= 10) { // The condition for entering the loop
result = result * base;
System.out.println(base + " raised to the power of " + exponent + " = " + result);
exponent++;
}
}
Uscita console:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0
Loop con una postcondizione
Ecco la seconda variante di questo loop:
do {
// Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
Ecco una spiegazione di cosa succede quando questo codice viene eseguito:
Il corpo del ciclo viene eseguito (immediatamente dopo la parola chiave do ).
Valutiamo l'espressione booleana che si trova tra parentesi dopo la parola chiave while .
Se l'espressione booleana restituisce true, andiamo al passaggio 1
Se l'espressione booleana restituisce false, saltiamo alla prima istruzione dopo il ciclo while .
Le due principali differenze rispetto al ciclo precedente sono: 1) il corpo del ciclo viene eseguito almeno una volta e 2) l'espressione booleana viene valutata dopo l'esecuzione del corpo del ciclo. Di conseguenza, questo tipo di ciclo while è chiamato ciclo con una postcondizione . Questa volta mostreremo una tabella di potenze di un numero che non supera 10000:
public static void main(String[] args) {
int base = 3; // The number that will be exponentiated
int result = base; // The result of exponentiation
int exponent = 1; // The initial exponent
do {
System.out.println(base + " raised to the power of " + exponent + " = " + result);
exponent++;
result = result * base;
} while (result < 10000); // The condition for exiting the loop
}
Uscita console:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
Process finished with exit code 0
Prestare attenzione ai cambiamenti nel codice. Confronta questo con il ciclo con una precondizione.
Fatti interessanti sul lavoro con i loop
Istruzioni di diramazione all'interno del corpo del ciclo
Ci sono due istruzioni che influenzano l'esecuzione all'interno di un ciclo: break (di cui parleremo più dettagliatamente nel prossimo capitolo) e
Continua.
continue — salta l'esecuzione del resto del corpo del ciclo nell'iterazione corrente e passa alla valutazione dell'espressione booleana dell'istruzione while. Se l'espressione restituisce true, il ciclo continua.
break — termina immediatamente l'esecuzione dell'iterazione corrente e trasferisce il controllo alla prima istruzione dopo il ciclo. Pertanto, questa istruzione termina l'esecuzione del ciclo corrente. Lo considereremo più in dettaglio nel prossimo articolo.
Ricorda il nostro esempio di frutta. Se non siamo sicuri della qualità delle mele, potremmo cambiare il codice usando un'istruzione
continue :
while (numberOfApplesInBowl > 0) {
apple = bowl.grabNextApple();
numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
if (apple.isBad()) { // This method returns true for rotten apples
apple.throwInGarbage();
continue; // Continue the loop. Jump to evaluation of numberOfApplesInBowl > 0
}
arrangeInPie(apple.peel().slice());
}
L' istruzione
continue viene spesso utilizzata quando le istruzioni nel corpo del ciclo devono essere eseguite se una determinata condizione è soddisfatta. Ad esempio, potremmo voler eseguire azioni quando viene attivato un sensore hardware (altrimenti, continuare semplicemente il ciclo in cui prendiamo le letture del sensore) o potremmo voler calcolare un'espressione solo su determinate iterazioni di un ciclo. Un esempio di quest'ultimo caso può essere visto nel nostro uso di un ciclo while per calcolare la somma di cubi di numeri naturali il cui quadrato è minore del numero di numeri. Confuso? Controlla il seguente codice:
public static void main(String[] args) {
int sum = 0; // Total amount
int i = 0; // Initial number in the series
int count = 20; // Number of numbers
while (i <= count) {
i++; // Get the next number — "i++" is equivalent to "i = i + 1"
if (i * i <= count) // If the square of the number is less than
continue; // the number of numbers, then we won't calculate the sum
// Jump to the next number in the loop
sum += i * i * i; // Otherwise, we calculate the sum of the cubes of numbers
} // "sum += i * i * i" is notation that is equivalent to "sum = sum + i * i * i"
System.out.println(sum); // Print the result
}
Ciclo infinito
Queste istruzioni di ramificazione vengono utilizzate più spesso nei cicli infiniti. Chiamiamo un ciclo infinito se la condizione booleana per uscire dal ciclo non è mai soddisfatta. Nel codice, assomiglia a questo:
while (true) {
// Loop body
}
In questo caso, un'istruzione
break ci aiuta a uscire dal ciclo. Questo tipo di loop è adatto quando si attende condizioni esterne determinate al di fuori del corpo del loop. Ad esempio, nei sistemi operativi o nei giochi (uscire dal ciclo significa uscire dal gioco). O quando si usano algoritmi che provano, ad ogni iterazione di un ciclo, a migliorare qualche risultato, ma limitano il numero di iterazioni in base al tempo trascorso o al verificarsi di un evento esterno (es. dama, scacchi o previsioni del tempo). Ricorda che in condizioni normali i cicli infiniti non sono desiderabili. Per dimostrare, torniamo all'elevazione a potenza:
public static void main(String[] args) {
int base = 3; // The number that will be exponentiated
int result = 1; // The result of exponentiation
int exponent = 1; // The initial exponent
while (true) {
result = result * base;
System.out.println(base + " raised to the power of " + exponent + " = " + result);
exponent++;
if (exponent > 10)
break; // Exit the loop
}
}
Uscita console:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0
Loop nidificati
E ora arriviamo al nostro argomento finale sui loop. Ricorda quella torta di mele (spero che tu non abbia fame al momento) e il nostro ciclo di sbucciatura di mele:
Se ci sono mele nella ciotola, eseguiamo i passaggi da 1.1 a 1.4:
1.1. Prendi una mela
1.2. Sbucciatela e tagliatela a fette
1.3. Disporre le fette di mela nella crosta di torta in una teglia
1.4. Ritorna al passaggio 1.
Descriviamo il processo di affettatura in modo più dettagliato:
Numero di fette = 0
Finché il numero di sezioni è < 12, eseguire i passaggi da 2.1 a 2.3
2.1. Taglia un'altra fetta dalla mela
2.2. Numero di fette++
2.3. Ritorna al passaggio 2
E lo aggiungeremo al nostro algoritmo per la creazione di torte:
Se ci sono mele nella ciotola, eseguiamo i passaggi da 1.1 a 1.6:
1.1. Prendi una mela
1.2. Sbuccialo
1.3. Numero di fette = 0
1.4. Finché il numero di sezioni è < 12, eseguire i passaggi da 1.4.1 a 1.4.3
1.4.1. Taglia un'altra fetta dalla mela
1.4.2. Numero di fette++
1.4.3. Ritorna al punto 1.4
1.5. Disporre le fette di mela nella crosta di torta in una teglia
1.6. Ritorna al passaggio 1.
Ora abbiamo un ciclo all'interno di un ciclo. Costrutti come questo sono molto comuni. Come ultimo esempio, costruiamo una delle tabelline che abbiamo imparato ad amare alle elementari.
public static void main(String[] args) {
// Print the second factors in a row
System.out.println(" 2 3 4 5 6 7 8 9");
int i = 2; // Assign the first factor to the variable
while (i < 10) { // First loop: execute as long as the first factor is less than 10
System.out.print(i + " | "); // Print the first factor at the beginning of the line
int j = 2; // The starting value of the second factor
while (j < 10) { // Second loop: execute as long as the second factor is less than 10
int product = i * j; // Calculate the product of the factors
if (product < 10) // If the product is a single digit, then we print two spaces after the product
System.out.print(product + " ");
else // Otherwise, print the product and one space after it
System.out.print(product + " ");
j++; // Increment the second factor by one
} // Go to the beginning of the second loop, i.e. "while (j < 10)"
System.out.println(); // Move to the next line on the console
i++; // Increment the first factor by one
} // Go to the beginning of the first loop, i.e. "while (i < 10)"
}
I loop (in particolare l' istruzione
while ) sono uno degli elementi costitutivi fondamentali del software. Risolvendo compiti su CodeGym, imparerai tutti i diversi tipi di loop, capirai le loro complessità e acquisirai abilità pratiche nell'usarli.
Diciamo che hai dieci mele, due mani e un coltello. Nella vita reale, sbucci in sequenza l'intera dozzina, seguendo lo stesso algoritmo per ogni mela. Ma come facciamo a fare in modo che un programma esegua un'azione ripetitiva per ogni mela?
GO TO FULL VERSION