Mens-erklæringen

Våre aller første programmer var en sekvens av instruksjoner som blir utført etter hverandre. Ingen gafler. Dette inkluderer HelloWorld, som viser en hilsen. Det inkluderer aritmetiske beregninger. Etter våre første programmer lærte vi å forgrene, dvs. hvordan få et program til å utføre ulike handlinger avhengig av spesifikke forhold. Her er koden for å kontrollere et sentralvarme- og klimaanlegg:


if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort)
    heaterOn();

Ta neste steg. I hverdagen utfører vi ofte ensartede repeterende handlinger, for eksempel å skrelle epler til en pai. Denne fascinerende prosessen kan beskrives som:

Hvis det er epler i bollen, utfører vi trinn 1.1 til 1.4:
1. 1.1. Ta et eple
2. 1.2. Skrell den og skjær den i skiver
3. 1.3. Anrett epleskivene i paibunnen i en panne
4. 1.4. Gå tilbake til trinn 1.

La oss si at du har ti epler, to hender og en kniv. I det virkelige liv skreller du sekvensielt hele dusinet, etter samme algoritme for hvert eple. Men hvordan får vi et program til å utføre en repeterende handling for hvert eple?

Vi binder oss til antall epler, men hvis vi ikke har nok av dem, vil noen av kommandoene bli utført uten "nyttelast" (og vi kan kutte oss selv mens vi prøver å skrelle et ikke-eksisterende eple).
Hvis det er flere epler enn kommandoer for å skrelle, vil noen av eplene bli stående uskrellet.
Slik kode er vanskelig å lese. Den har mange repetisjoner og er vanskelig å modifisere.

Loops er utsagn som gjør at handlinger kan utføres gjentatte ganger

Javas while loop vil fungere bra i vårt tilfelle. Denne konstruksjonen setter flere handlinger inn i en kortfattet og forståelig struktur. Ved å bruke en while- løkke kan en eple-skjæringsalgoritme for en pai se slik ut 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 varianten av while- setningen er slik:


while (Boolean expression) {
	// Loop body — the statement(s) that are repeatedly executed
}

Her er en trinnvis forklaring på hva som skjer når denne koden kjøres:

Vi evaluerer det boolske uttrykket som finnes i parentes etter nøkkelordet while .
Hvis det boolske uttrykket evalueres til sant, blir setningene i løkketeksten utført . Etter at den siste setningen i loop-kroppen er utført, går vi til trinn 1
Hvis det boolske uttrykket evalueres til usant, hopper vi til den første setningen etter while- løkken.

Løkke med en forutsetning

Fordi vi alltid evaluerer det boolske uttrykket (betingelsen for å gå inn i løkken) før vi utfører løkkekroppen, kalles denne formen for while -løkken ofte en løkke med en forutsetning . La oss bygge en tabell over de ti første potensene til et tall:


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++;
    }
}

Konsoll utgang:


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 andre varianten av denne løkken:


do {
    // Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);

Her er en forklaring på hva som skjer når denne koden kjøres:

Løkketeksten utføres (umiddelbart etter do nøkkelordet).
Vi evaluerer det boolske uttrykket som finnes i parentes etter nøkkelordet while .
Hvis det boolske uttrykket evalueres til sant, går vi til trinn 1
Hvis det boolske uttrykket evalueres til usant, hopper vi til den første setningen etter while- løkken.

De to hovedforskjellene fra forrige sløyfe er: 1) løkkelegemet utføres minst én gang og 2) det boolske uttrykket evalueres etter at løkkelegemet er utført. Følgelig kalles denne typen while- løkke en løkke med en postbetingelse . Denne gangen viser vi en potenstabell for et tall som 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
}

Konsoll utgang:


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 oppmerksom på endringene i koden. Sammenlign dette med løkken med en forutsetning.

Interessante fakta om å jobbe med looper

Forgreningsuttalelser i løkkekroppen

Det er to utsagn som påvirker utførelse i en loop: pause (som vi vil diskutere mer detaljert i neste kapittel) og Fortsette.

fortsett — hopper over kjøringen av resten av løkketeksten i gjeldende iterasjon og hopper til evalueringen av while-setningens boolske uttrykk. Hvis uttrykket evalueres til sant, fortsetter loopen.
break — avslutter umiddelbart utførelsen av gjeldende iterasjon og overfører kontrollen til den første setningen etter loopen. Dermed avslutter denne setningen kjøringen av gjeldende sløyfe. Vi vil vurdere det mer detaljert i neste artikkel.

Husk frukteksemplet vårt. Hvis vi er usikre på kvaliteten på eplene, kan vi endre koden ved å bruke en continue -setning:


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());
}

Fortsett - setningen brukes ofte når setninger i loop-kroppen må utføres hvis en bestemt betingelse er oppfylt. For eksempel kan det hende vi ønsker å utføre handlinger når en maskinvaresensor utløses (ellers fortsett ganske enkelt løkken der vi tar sensoravlesninger), eller vi vil kanskje beregne et uttrykk bare på visse iterasjoner av en sløyfe. Et eksempel på sistnevnte tilfelle kan sees i vår bruk av en while-løkke for å beregne summen av kuber av naturlige tall hvis kvadrat er mindre enn antall tall. Forvirret? Sjekk ut 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 forgreningssetningene brukes oftest i uendelige løkker. Vi kaller en løkke uendelig hvis den boolske betingelsen for å gå ut av løkken aldri er oppfylt. I koden ser det omtrent slik ut:


while (true) {
    // Loop body 
}

I dette tilfellet hjelper en break -setning oss å gå ut av loopen. Denne typen sløyfe er egnet når man venter på ytre forhold bestemt utenfor sløyfens kropp. For eksempel i operativsystemer eller spill (å gå ut av loopen betyr å avslutte spillet). Eller når du bruker algoritmer som prøver, med hver iterasjon av en løkke, å forbedre noe resultat, men begrenser antall iterasjoner basert på medgått tid eller forekomsten av en ekstern hendelse (f.eks. dam, sjakk eller værmelding). Husk at uendelige løkker under normale forhold ikke er ønskelig. For å demonstrere, la oss gå tilbake 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
    }
}

Konsoll utgang:


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

Nestede løkker

Og nå kommer vi til vårt siste emne om loops. Husk den eplepaien (håper du ikke er sulten for øyeblikket) og epleskrellen vår:

Hvis det er epler i bollen, utfører vi trinn 1.1 til 1.4:
1. 1.1. Ta et eple
2. 1.2. Skrell den og skjær den i skiver
3. 1.3. Anrett epleskivene i paibunnen i en panne
4. 1.4. Gå tilbake til trinn 1.

La oss beskrive skjæreprosessen mer detaljert:

Antall skiver = 0
Så lenge antallet skiver er < 12, utfør trinn 2.1 til 2.3
1. 2.1. Skjær en annen skive av eplet
2. 2.2. Antall skiver++
3. 2.3. Gå tilbake til trinn 2

Og vi vil legge dette til vår kakefremstillingsalgoritme:

Hvis det er epler i bollen, utfører vi trinn 1.1 til 1.6:
1. 1.1. Ta et eple
2. 1.2. Skrell den
3. 1.3. Antall skiver = 0
4. 1.4. Så lenge antallet skiver er < 12, utfør trinn 1.4.1 til 1.4.3
5. 1.5. Anrett epleskivene i paibunnen i en panne
6. 1.6. Gå tilbake til trinn 1.

Nå har vi en løkke i en løkke. Slike konstruksjoner er veldig vanlige. Som et siste eksempel, la oss bygge en av multiplikasjonstabellene vi lærte å elske på barneskolen.


 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)"
}

Konsoll utgang:


    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 (spesielt while - setningen) er en av de grunnleggende byggesteinene i programvare. Ved å løse oppgaver på CodeGym vil du lære alle de forskjellige typene looper, forstå deres forviklinger og få praktiske ferdigheter i å bruke dem.