Onze allereerste programma's waren een reeks instructies die de een na de ander werden uitgevoerd. Geen vorken. Dit omvat HelloWorld, dat een begroeting weergeeft. Het omvat rekenkundige berekeningen. Na onze eerste programma's hebben we geleerd hoe we moeten vertakken, dwz hoe we een programma verschillende acties kunnen laten uitvoeren, afhankelijk van specifieke omstandigheden. Hier is code voor het regelen van een centraal verwarmings- en airconditioningsysteem:
Laten we zeggen dat je tien appels, twee handen en één mes hebt. In het echte leven schil je achtereenvolgens het hele dozijn, volgens hetzelfde algoritme voor elke appel. Maar hoe zorgen we ervoor dat een programma een herhalende actie uitvoert voor elke appel?
doorgaan.
if (tempRoom>tempComfort)
airConditionerOn();
if (tempRoom<tempComfort)
heaterOn();
Zet de volgende stap. In het dagelijks leven voeren we vaak uniforme repetitieve handelingen uit, bijvoorbeeld appels schillen voor een taart. Dit fascinerende proces kan worden omschreven als:
-
Als er appels in de kom zitten, dan voeren we stappen 1.1 t/m 1.4 uit:
- 1.1. Pak een appel
- 1.2. Schil het en snijd het in plakjes
- 1.3. Schik de appelschijfjes in de taartbodem in een pan
- 1.4. Keer terug naar stap 1.
![Het while-statement - 2](https://cdn.codegym.cc/images/article/9096f357-1bc3-49dc-8a03-5fb92f8d8713/800.jpeg)
- We binden ons aan het aantal appels, maar als we er niet genoeg van hebben, worden sommige commando's uitgevoerd zonder een "payload" (en kunnen we onszelf snijden terwijl we proberen een niet-bestaande appel te schillen).
- Als er meer appels zijn dan commando's om te schillen, dan blijven sommige appels ongeschild.
- Dergelijke code is moeilijk te lezen. Het bevat veel herhalingen en is moeilijk aan te passen.
Lussen zijn instructies waarmee acties herhaaldelijk kunnen worden uitgevoerd
De while- lus van Java werkt in ons geval goed. Deze constructie plaatst meerdere acties in een beknopte en begrijpelijke structuur. Met behulp van een while- lus zou een algoritme voor het snijden van appels voor een taart er in Java zo uit kunnen zien:
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.");
Opdrachtsyntaxis
De eerste variant van het while- statement ziet er als volgt uit:
while (Boolean expression) {
// Loop body — the statement(s) that are repeatedly executed
}
Hier is een stapsgewijze uitleg van wat er gebeurt wanneer deze code wordt uitgevoerd:
- We evalueren de Booleaanse uitdrukking tussen haakjes na het sleutelwoord while .
- Als de Booleaanse uitdrukking resulteert in waar, worden de instructies in de hoofdtekst van de lus uitgevoerd. Nadat de laatste instructie in de lus is uitgevoerd, gaan we naar stap 1
- Als de Booleaanse uitdrukking resulteert in onwaar, springen we naar de eerste instructie na de while- lus.
Lus met een voorwaarde
Omdat we altijd de Booleaanse uitdrukking evalueren (de voorwaarde om de lus binnen te gaan) voordat we de hoofdtekst van de lus uitvoeren, wordt deze vorm van de while- lus vaak een lus met een preconditie genoemd . Laten we een tabel maken met de eerste tien machten van een getal:
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++;
}
}
Console-uitvoer:
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
Lus met een postconditie
Hier is de tweede variant van deze lus:
do {
// Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
Hier is een uitleg van wat er gebeurt wanneer deze code wordt uitgevoerd:
- De hoofdtekst van de lus wordt uitgevoerd (onmiddellijk na het sleutelwoord do ).
- We evalueren de Booleaanse uitdrukking tussen haakjes na het sleutelwoord while .
- Als de Booleaanse uitdrukking resulteert in waar, gaan we naar stap 1
- Als de Booleaanse uitdrukking resulteert in onwaar, springen we naar de eerste instructie na de while- lus.
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
}
Console-uitvoer:
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
Let op de wijzigingen in de code. Vergelijk dit met de lus met een randvoorwaarde.
Interessante feiten over het werken met lussen
Vertakkingsinstructies binnen de hoofdtekst van de lus
Er zijn twee instructies die de uitvoering binnen een lus beïnvloeden: break (die we in het volgende hoofdstuk in meer detail zullen bespreken) en- continue — slaat de uitvoering van de rest van de lus in de huidige iteratie over en springt naar de evaluatie van de Booleaanse uitdrukking van de while-instructie. Als de expressie resulteert in waar, gaat de lus verder.
- break — beëindigt onmiddellijk de uitvoering van de huidige iteratie en draagt de controle over aan de eerste instructie na de lus. Deze instructie beëindigt dus de uitvoering van de huidige lus. We zullen het in meer detail bekijken in het volgende artikel.
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());
}
De instructie
continue wordt vaak gebruikt wanneer instructies in de lus moeten worden uitgevoerd als aan een bepaalde voorwaarde is voldaan. We willen bijvoorbeeld acties uitvoeren wanneer een hardwaresensor wordt geactiveerd (anders gaan we gewoon door met de lus waarin we sensormetingen doen) of we willen misschien alleen een uitdrukking berekenen voor bepaalde iteraties van een lus. Een voorbeeld van het laatste geval is te zien in ons gebruik van een while-lus om de som van de kubussen van natuurlijke getallen te berekenen waarvan het kwadraat kleiner is dan het aantal getallen. Verward? Bekijk de volgende code:
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
}
Oneindige lus
Deze vertakkingsinstructies worden het vaakst gebruikt in oneindige lussen. We noemen een lus oneindig als aan de Booleaanse voorwaarde voor het verlaten van de lus nooit wordt voldaan. In code ziet het er ongeveer zo uit:
while (true) {
// Loop body
}
In dit geval helpt een
break- statement ons om de lus te verlaten. Dit type lus is geschikt wanneer wordt gewacht op externe omstandigheden die buiten het lichaam van de lus worden bepaald. Bijvoorbeeld in besturingssystemen of games (de lus verlaten betekent de game verlaten). Of bij het gebruik van algoritmen die bij elke iteratie van een lus een resultaat proberen te verbeteren, maar het aantal iteraties beperken op basis van de verstreken tijd of het optreden van een externe gebeurtenis (bijvoorbeeld dammen, schaken of weersvoorspellingen). Onthoud dat oneindige lussen onder normale omstandigheden niet wenselijk zijn. Om dit te demonstreren, gaan we terug naar machtsverheffen:
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
}
}
Console-uitvoer:
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
Geneste lussen
En nu komen we bij ons laatste onderwerp over loops. Denk aan die appeltaart (ik hoop dat je op dit moment geen honger hebt) en onze appelschillus:-
Als er appels in de kom zitten, dan voeren we stappen 1.1 t/m 1.4 uit:
- 1.1. Pak een appel
- 1.2. Schil het en snijd het in plakjes
- 1.3. Schik de appelschijfjes in de taartbodem in een pan
- 1.4. Keer terug naar stap 1.
- Aantal plakjes = 0
-
Zolang het aantal plakjes < 12 is, voert u stap 2.1 tot 2.3 uit
- 2.1. Snijd nog een plakje van de appel
- 2.2. Aantal plakjes++
- 2.3. Keer terug naar stap 2
-
Als er appels in de kom zitten, dan voeren we stappen 1.1 t/m 1.6 uit:
- 1.1. Pak een appel
- 1.2. Pel het
- 1.3. Aantal plakjes = 0
- 1.4. Zolang het aantal plakjes < 12 is, voert u stap 1.4.1 tot 1.4.3 uit
- 1.4.1. Snijd nog een plakje van de appel
- 1.4.2. Aantal plakjes++ 1.4.3. Keer terug naar stap 1.4
- 1.5. Schik de appelschijfjes in de taartbodem in een pan
- 1.6. Keer terug naar stap 1.
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)"
}
Console-uitvoer:
2 3 4 5 6 7 8 9
2 | 4 6 8 10 12 14 16 18
3 | 6 9 12 15 18 21 24 27
4 | 8 12 16 20 24 28 32 36
5 | 10 15 20 25 30 35 40 45
6 | 12 18 24 30 36 42 48 54
7 | 14 21 28 35 42 49 56 63
8 | 16 24 32 40 48 56 64 72
9 | 18 27 36 45 54 63 72 81
Process finished with exit code 0
Loops (in het bijzonder het
while- statement) zijn een van de fundamentele bouwstenen van software. Door taken op CodeGym op te lossen, leer je alle verschillende soorten loops kennen, leer je hun fijne kneepjes begrijpen en doe je praktische vaardigheden op in het gebruik ervan.
GO TO FULL VERSION