Vores allerførste programmer var en sekvens af instruktioner, der udføres efter hinanden. Ingen gafler. Dette inkluderer HelloWorld, som viser en hilsen. Det inkluderer aritmetiske beregninger. Efter vores første programmer lærte vi at forgrene, altså hvordan man får et program til at udføre forskellige handlinger afhængigt af specifikke forhold. Her er kode til styring af et centralvarme- og klimaanlæg:
if (tempRoom>tempComfort)
airConditionerOn();
if (tempRoom<tempComfort)
heaterOn();
Tag det næste skridt. I hverdagen udfører vi ofte ensartede gentagne handlinger, for eksempel at skrælle æbler til en tærte. Denne fascinerende proces kan beskrives som:
Hvis der er æbler i skålen, så udfører vi trin 1.1 til 1.4:
1.1. Snup et æble
1.2. Skræl den og skær den i skiver
1.3. Anret æbleskiverne i tærtebunden i en gryde
1.4. Vend tilbage til trin 1.
Lad os sige, at du har ti æbler, to hænder og en kniv. I det virkelige liv skræller du sekventielt hele dusinet, efter den samme algoritme for hvert æble. Men hvordan får vi et program til at udføre en gentagen handling for hvert æble?
Vi binder os til antallet af æbler, men hvis vi ikke har nok af dem, så vil nogle af kommandoerne blive udført uden en "nyttelast" (og vi kan skære os selv, mens vi forsøger at skrælle et ikke-eksisterende æble).
Hvis der er flere æbler end kommandoer til at skrælle, så ville nogle af æblerne stå uskrællede.
En sådan kode er svær at læse. Den har mange gentagelser og er svær at ændre.
Loops er udsagn, der gør det muligt at udføre handlinger gentagne gange
Javas while- løkke vil fungere godt i vores tilfælde. Denne konstruktion sætter flere handlinger ind i en kortfattet og forståelig struktur. Ved at bruge en while- løkke kan en æbleskærealgoritme til en tærte se sådan ud i 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.");
Kommandosyntaks
Den første variant af while -sætningen er sådan:
while (Boolean expression) {
// Loop body — the statement(s) that are repeatedly executed
}
Her er en trin-for-trin forklaring på, hvad der sker, når denne kode udføres:
Vi evaluerer det boolske udtryk, der findes i parentes efter nøgleordet while .
Hvis det boolske udtryk evalueres til sandt, udføres sætningerne i loop-kroppen . Når den sidste sætning i loop-kroppen er udført, går vi til trin 1
Hvis det boolske udtryk evalueres til falsk, så hopper vi til den første sætning efter while- løkken.
Løkke med en forudsætning
Fordi vi altid evaluerer det boolske udtryk (betingelsen for at gå ind i løkken), før vi udfører løkkens krop, kaldes denne form for while -løkken ofte en løkke med en forudsætning . Lad os bygge en tabel over de første ti potenser af et tal:
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++;
}
}
Konsoludgang:
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
Løkke med postcondition
Her er den anden variant af denne løkke:
do {
// Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
Her er en forklaring på, hvad der sker, når denne kode udføres:
Løkketeksten udføres (umiddelbart efter do nøgleordet).
Vi evaluerer det boolske udtryk, der findes i parentes efter nøgleordet while .
Hvis det boolske udtryk evalueres til sandt, så går vi til trin 1
Hvis det boolske udtryk evalueres til falsk, så hopper vi til den første sætning efter while- løkken.
De to væsentligste forskelle fra den forrige løkke er: 1) løkkelegemet udføres mindst én gang og 2) det boolske udtryk evalueres efter løkkelegemet er eksekveret. Følgelig kaldes denne slags while -løkke en løkke med en postbetingelse . Denne gang viser vi en tabel over potenser af et tal, der ikke overstiger 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
}
Konsoludgang:
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
Vær opmærksom på ændringerne i koden. Sammenlign dette med løkken med en forudsætning.
Interessante fakta om at arbejde med loops
Forgreningsudsagn i løkketeksten
Der er to udsagn, der påvirker udførelsen inden for en loop: pause (som vi vil diskutere mere detaljeret i næste kapitel) og
Blive ved.
fortsæt — springer udførelse af resten af loop-kroppen over i den aktuelle iteration og springer til evalueringen af while-sætningens boolske udtryk. Hvis udtrykket evalueres til sandt, fortsætter løkken.
break — afslutter øjeblikkeligt udførelsen af den aktuelle iteration og overfører kontrol til den første sætning efter løkken. Denne sætning afslutter således udførelsen af den aktuelle sløjfe. Vi vil overveje det mere detaljeret i den næste artikel.
Husk vores frugteksempel. Hvis vi er usikre på kvaliteten af æblerne, kan vi ændre koden ved at bruge en
fortsæt -sætning:
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());
}
Fortsæt
- sætningen bruges ofte, når sætninger i loop-kroppen skal udføres, hvis en bestemt betingelse er opfyldt. For eksempel vil vi måske udføre handlinger, når en hardwaresensor udløses (ellers skal du blot fortsætte den løkke, hvori vi tager sensoraflæsninger), eller vi vil måske kun beregne et udtryk på bestemte iterationer af en løkke. Et eksempel på sidstnævnte tilfælde kan ses i vores brug af en while-løkke til at beregne summen af terninger af naturlige tal, hvis kvadrat er mindre end antallet af tal. Forvirret? Tjek følgende kode:
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
}
Uendelig løkke
Disse forgreningsudsagn bruges oftest i uendelige sløjfer. Vi kalder en løkke uendelig, hvis den boolske betingelse for at forlade løkken aldrig er opfyldt. I koden ser det sådan ud:
while (true) {
// Loop body
}
I dette tilfælde hjælper en
break- sætning os med at forlade sløjfen. Denne type sløjfe er velegnet, når man venter på eksterne forhold bestemt uden for løkkens krop. For eksempel i operativsystemer eller spil (at forlade løkken betyder at forlade spillet). Eller når du bruger algoritmer, der forsøger, med hver iteration af en loop, at forbedre et eller andet resultat, men begrænser antallet af iterationer baseret på forløbet tid eller forekomsten af en ekstern begivenhed (f.eks. dam, skak eller vejrudsigt). Husk, at uendelige sløjfer under normale forhold ikke er ønskelige. For at demonstrere, lad os vende tilbage til eksponentiering:
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
}
}
Konsoludgang:
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
Indlejrede løkker
Og nu kommer vi til vores sidste emne om loops. Husk den æbletærte (jeg håber du ikke er sulten i øjeblikket) og vores æbleskrælleløkke:
Hvis der er æbler i skålen, så udfører vi trin 1.1 til 1.4:
1.1. Snup et æble
1.2. Skræl den og skær den i skiver
1.3. Anret æbleskiverne i tærtebunden i en gryde
1.4. Vend tilbage til trin 1.
Lad os beskrive udskæringsprocessen mere detaljeret:
Antal skiver = 0
Så længe antallet af skiver er < 12, så udfør trin 2.1 til 2.3
2.1. Skær endnu en skive af æblet
2.2. Antal skiver++
2.3. Vend tilbage til trin 2
Og vi tilføjer dette til vores tærtefremstillingsalgoritme:
Hvis der er æbler i skålen, så udfører vi trin 1.1 til 1.6:
1.1. Snup et æble
1.2. Skræl den
1.3. Antal skiver = 0
1.4. Så længe antallet af skiver er < 12, så udfør trin 1.4.1 til 1.4.3
1.4.1. Skær endnu en skive af æblet
1.4.2. Antal skiver++
1.4.3. Vend tilbage til trin 1.4
1.5. Anret æbleskiverne i tærtebunden i en gryde
1.6. Vend tilbage til trin 1.
Nu har vi en løkke i en løkke. Konstruktioner som denne er meget almindelige. Som et sidste eksempel, lad os bygge en af de multiplikationstabeller, vi lærte at elske i folkeskolen.
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)"
}
Loops (især
while - sætningen) er en af de grundlæggende byggesten i software. Ved at løse opgaver på CodeGym vil du lære alle de forskellige slags loops, komme til at forstå deres forviklinger og få praktiske færdigheder i at bruge dem.
Lad os sige, at du har ti æbler, to hænder og en kniv. I det virkelige liv skræller du sekventielt hele dusinet, efter den samme algoritme for hvert æble. Men hvordan får vi et program til at udføre en gentagen handling for hvert æble?
GO TO FULL VERSION