3.5. Løkker

3.5.1. while-løkken

while-løkken har formen:

 
    while (betingelse) kommando; 

Kommandoen udføres igen og igen mens betingelsen er opfyldt. Dvs. før kommandoen udføres, undersøges betingelsen, og det kontrolleres, at den er opfyldt (se Figur 3-7).

Oftest grupperer man flere kommandoer i en blok.

 
public class Alder4 
{ 
  public static void main(String[] args)  
  { 
    int alder; 
    alder = 15; 
 
    while (alder < 18) 
    { 
      System.out.println("Du er "+alder+" år. Vent til du bliver ældre."); 
      alder = alder + 1; 
      System.out.println("Tillykke med fødselsdagen!"); 
    } 
 
    System.out.println("Nu er du "+alder+" år og myndig."); 
  } 
} 

Resultatet bliver

 
Du er 15 år. Vent til du bliver ældre. 
Tillykke med fødselsdagen! 
Du er 16 år. Vent til du bliver ældre. 
Tillykke med fødselsdagen! 
Du er 17 år. Vent til du bliver ældre. 
Tillykke med fødselsdagen! 
Nu er du 18 år og myndig. 

Før løkken starter, har alder en startværdi på 15. Under hvert gennemløb tælles variablen 1 op. På et tidspunkt, når alder er talt op til 18, er betingelsen ikke mere opfyldt, og programudførelsen fortsætter efter løkken.

Med en løkke kan vi lave Kvadratrod-programmet nemmere. I stedet for at skrive den samme kommando igen og igen kan vi lave en løkke (sammenlign med Kvadratrod Afsnit 3.2.5).

 
public class Kvadratrod2 
{ 
  public static void main(String[] args)  
  { 
    int n; 
    n = 0; 
 
    while (n <= 10) 
    { 
      System.out.println("kvadratroden af "+n+" er " + Math.sqrt(n)); 
      n = n + 1; 
    } 
  } 
} 

Resultatet bliver

 
kvadratroden af 0 er 0.0 
kvadratroden af 1 er 1.0 
kvadratroden af 2 er 1.4142135623730951 
kvadratroden af 3 er 1.7320508075688772 
kvadratroden af 4 er 2.0 
kvadratroden af 5 er 2.23606797749979 
kvadratroden af 6 er 2.449489742783178 
kvadratroden af 7 er 2.6457513110645907 
kvadratroden af 8 er 2.8284271247461903 
kvadratroden af 9 er 3.0 
kvadratroden af 10 er 3.1622776601683795 

En tællevariabel er en variabel, der tælles op i en løkke, indtil den når en bestemt øvre grænse. I eksemplerne ovenfor bruges alder og n som tællevariabler.

Herunder udskriver vi 7-tabellen ved hjælp af tællevariablen n:

 
public class Syvtabel 
{ 
  public static void main(String[] args)  
  { 
    int n; 
    n = 1; 
 
    while (n <= 10) 
    { 
      System.out.println(n+" : "+ 7*n); 
      n = n + 1; 
    } 
  } 
} 

Resultatet bliver

 
1 : 7 
2 : 14 
3 : 21 
4 : 28 
5 : 35 
6 : 42 
7 : 49 
8 : 56 
9 : 63 
10 : 70 

Tællevariabel-formen er den mest almindelige for løkker, men man kan sagtens komme ud for andre former for løkker. Der kan f.eks. godt indgå et regneudtryk i betingelsen.

3.5.2. for-løkken

For-løkken er specielt velegnet til løkker med en tællevariabel. Den har formen

 
for (initialisering; 
betingelse; opdatering) 
kommando; 

• initialisering er en (evt.: erklæring og) tildeling af en tællevariabel, f.eks. alder = 15

• betingelse er et logisk udtryk, der angiver betingelsen for, at løkken skal fortsætte med at blive udført, f.eks. alder < 18

• opdatering er ændringen i tællevariablen, f.eks. alder = alder + 1

Det kan indenad læses som "for startværdi, så længe betingelse udfør: kommando og opdatering", f.eks. "for alder = 15, så længe alder < 18 udfør: Skriv "du er.." og tæl alder 1 op".

En for-løkke og en while-løkke supplerer hinanden. De har præcis samme funktion, men for-løkken er mere kompakt og bekvem, når man ønsker at lave en almindelig løkke, der udføres et bestemt antal gange. Dette program gør det samme som Syvtabel-eksemplet, men med en for-løkke:

 
public class Syvtabel2 
{ 
  public static void main(String[] args)  
  { 
    int n; 
    for (n=1; n<=10; n=n+1) 
      System.out.println(n+" : "+ 7*n); 
  } 
} 

Programmører er dovne væsner og bruger ofte for-løkken til optælling, fordi der skal skrives mindre end i en while-løkke.

Man ser også ofte, at de bruger operatoren ++ til at tælle en variabel op i en løkke: "alder++" svarer altså til "alder=alder+1", men med mindre skrivearbejde. Tilsvarende findes --, som tæller en variabel en ned, f.eks. alder--.

3.5.3. Indlejrede løkker

En betingelse eller en løkke kan stå ethvert sted i en metode, og altså også inden i en anden løkke eller en betingelse.

Herunder har vi syvtabellen igen, men denne gang "brokker" programmet sig, når det når op på 6, og efter 8 skriver den "ved ikke" i stedet for at regne resultatet ud.

 
public class Syvtabel3 
{ 
  public static void main(String[] args)  
  { 
    for (int n=1; n<=10; n++)  // n++ gør det samme som n=n+1 
    { 
      if (n == 6) System.out.println("puha, nu bliver det svært."); 
 
      if (n < 8)   System.out.println(n+" : "+ 7*n); 
      else System.out.println(n+" : (ved ikke)"); 
    } 
  } 
} 

Resultatet bliver

 
1 : 7 
2 : 14 
3 : 21 
4 : 28 
5 : 35 
puha, nu bliver det svært. 
6 : 42 
7 : 49 
8 : (ved ikke) 
9 : (ved ikke) 
10 : (ved ikke) 

Vi kan også lave løkker i løkker. Herunder udregner vi n*7 ved at lægge 7 sammen n gange.

 
public class Syvtabel4 
{ 
  public static void main(String[] args)  
  { 
    for (int n=1; n<=10; n=n+1) 
    { 
      int sum = 0; 
      for (int j=0; j<n; j++) sum = sum + 7; 
 
      System.out.println(n+" : "+ sum); 
    } 
  } 
} 

Resultatet bliver

 
1 : 7 
2 : 14 
3 : 21 
4 : 28 
5 : 35 
6 : 42 
7 : 49 
8 : 56 
9 : 63 
10 : 70 

3.5.4. Uendelige løkker

Hvis programmøren ikke er omhyggelig, kan han komme til at lave en løkke, hvor betingelsen vedbliver at være sand. Så bliver programudførelsen i løkken i al evighed (eller indtil brugeren afbryder programmet).

Lad os f.eks. sige, at programmøren er kommet til at skrive '-' i stedet for '+' i opdateringen af n i while-løkken fra Syvtabel-programmet. Nu vil computeren tælle nedad:

 
public class SyvtabelFejl 
{ 
  public static void main(String[] args)  
  { 
    for (int n=1; n<=10; n=n-1) 
      System.out.println(n+" : "+ 7*n); 
  } 
} 

Resultatet bliver

 
1 : 7 
0 : 0 
-1 : -7 
-2 : -14 
-3 : -21 
-4 : -28 

... og så videre i det uendelige. Løkken vil aldrig stoppe, fordi n vedbliver at være mindre end 10.

En anden faldgrube er at komme til at sætte et semikolon efter en while-løkke:

 
    while (n <= 10); 

Oversætteren vil tro, at der ikke er nogen kommando, der skal udføres, og blot undersøge betingelsen igen og igen og igen og igen... Da n ikke ændrer sig, vil programmet aldrig stoppe.

Det er programmørens ansvar at sikre, at betingelsen i en løkke på et tidspunkt ikke mere opfyldes, så programmet ikke går i uendelig løkke.

3.5.5. Opgaver

1. Prøv at køre hvert eksempel, og forvis dig om, at du forstår det.Mange udviklingsværktøjer understøtter trinvis gennemgang til fejlfinding (eng.: debugging). Prøv trinvis gennemgang i dit værktøj, og hold øje med variablerne. (I JBuilder og JDeveloper gøres det med F8 "step over").

2. Omskriv Alder4-programmet til at bruge en for-løkke.

3. Lav et program, der tæller nedad fra 10 til 1.

4. Lav et program, der udregner værdien af 1+2+3+ ... +20.

5. Ret programmet til at udregne værdierne af 1+2+3+ ... +n, når n er 10, 11, .. 30 (vink: brug en indlejret løkke).

6. Lav et program, der udskriver 1-tabellen, 2-tabellen, .. op til 10-tabellen.

7. Skriv et program, som for ligningen y=3*x*x+6*x+9 udskriver værdierne af y for x=0, x=1,x= 2, x=3 ... x=10. Ret det derefter til at skrive ud for x=0,x=10,x=20,x=30...x=100.