Kapittel 2. Grunnleggende programelementer. 2.1 Enkle uttrykk i metodekall. Evaluering av argumenter

Transkript

1 Kapittel 2 Grunnleggende programelementer Dette kapitlet beskriver en del grunnleggende elementer vi må beherske for å kunne skrive programmer. Mange av disse elementene finnes i flere programmeringsspråk, og forståelse av dem er derfor nyttig også dersom man ønsker å lære seg andre språk. Fokus i kapitlet er likevel på hvordan Java realiserer slike elementære byggesteiner. Korte, men fullstendige eksempelprogrammer gjør at man fort kan komme i gang og teste ut hvordan ting virker. 2.1 Enkle uttrykk i metodekall Evaluering av argumenter Enkle testprogrammer kan regne ut de verdiene man trenger, og skrive dem rett ut på skjermen. Vil man for eksempel skrive ut summen av de to heltallene 9 og 7, kan følgende metodekall i Java brukes: System.out.println(9+7); Her kalles hvert av tallene 9 og 7 for en litteral (eng. literal) og 9+7 for et enkelt uttrykk (eng. simple expression). En litteral er en verdi skrevet direkte i kildekoden. Et enkelt uttrykk består kun av én operasjon. Uttrykket 9+7 står innenfor parentesene til println()-metoden. Det betyr at resultatet av dette uttrykket blir sendt til metoden som et argument. Argumenter er verdier som sendes inn til en metode for å påvirke resultatet av metodekallet. I dette tilfellet vil heltallet 16 bli sendt inn til println()-metoden, som så skriver denne verdien ut på skjermen som en tekststreng. Argumentet som gis inn til println()-metoden, vil bli skrevet ut på én linje, etterfulgt av linjeskift. Program 2.1 viser et lite Java-program som regner ut noen enkle uttrykk og deretter skriver resultatene ut på skjermen. Merk at vi i de to første tilfellene skriver ut verdien av uttrykket for seg, mens vi de to siste gangene skriver ut både tekst- og tallverdier i samme metodekall. Både linje (1) og linje (2) gir den utskriften man vil forvente, henholdsvis 16 og 63, som er verdien av uttrykkene 9+7 og 9*7.

2 14 Kapittel 2 Grunnleggende programelementer Hvis vi derimot vil skrive ut både tekst og tallverdier sammen, må vi passe på at verdien av uttrykket blir regnet ut før den settes sammen med teksten. Ellers kan resultatet bli feil i forhold til det vi ønsket å beregne, slik som i utskriften fra linje (3) i Program 2.1: Verdien av er : 97 Dette skjer fordi kompilatoren vil oppfatte operatoren + som en sammenslåing av tekststrenger når man blander tekst og tallverdier. Den vil derfor konvertere ett og ett heltall til en tekststreng og slå denne sammen med den foregående strengen, i stedet for at tallverdiene summeres først, slik vi gjerne ville forventet. (Operatoren + er nærmere forklart i delavsnittet "Strengsammenslåing" på side 59.) I linje (4) har vi passet på å sette parenteser rundt uttrykket. Dette sikrer at verdien av det blir evaluert som en tallverdi før det skjøtes sammen med strengen foran. Utskriften fra denne linjen vil være Verdien av (9 + 7) er : 16 som er den verdien vi ville forvente. Figur 2.1 viser hvordan argumentet til println()-metoden evalueres for en del av metodekallene i Program 2.1. Program 2.1 Utregning av enkle uttrykk class EnkleUttrykk { public static void main(string[] args) { System.out.println("(a) Skriver tekst og verdier for seg."); System.out.println("Verdien av er : "); System.out.println(9 + 7); // (1) System.out.println("Verdien av 9 * 7 er : "); System.out.println(9 * 7); // (2) System.out.println("(b) Skriver tekst og verdier i samme kall."); System.out.println("Verdien av er : " ); // (3) System.out.println("Verdien av (9 + 7) er : " + (9 + 7)); // (4) Kjøring av programmet: (a) Skriver tekst og verdier for seg. Verdien av er : 16 Verdien av 9 * 7 er : 63 (b) Skriver tekst og verdier i samme kall. Verdien av er : 97 Verdien av (9 + 7) er : 16

3 Avsnitt 2.1 Enkle uttrykk i metodekall 15 Figur 2.1 Evaluering av argumenter addisjon 16 System.out.println( 16 ); (a) enkelt uttrykk "Verdien av er : " tall konverteres til streng "Verdien av er : " +"9"+ 7 skjøting av strenger "Verdien av er : 9" + 7 tall konverteres til streng "Verdien av er : 9" +"7" skjøting av strenger System.out.println( "Verdien av er : 97" ); (b) blanding av tekst og enkelt uttrykk "Verdien av er : " + (9 + 7) uttrykk beregnes først "Verdien av er : " + 16 tall konverteres til streng "Verdien av er : " + "16" skjøting av strenger System.out.println( "Verdien av er : 16" ); (c) blanding av tekst og enkelt uttrykk, der uttrykket beregnes først Standard ut-enhet Program 2.1 skrev ut tekst på skjermen ved hjelp av System.out-objektet. Dette objektet kalles standard ut-enhet (eng. standard out), og Java vil sørge for at det alltid er tilgjengelig for alle Java-programmer. I utgangspunktet er System.out-objektet knyttet til skjermen som programmet kjøres fra. Standard ut-enhet kan imidlertid kobles til forskjellige typer enheter og andre objekter, som for eksempel filer, alt etter hva vi har behov for. Alle bestanddeler av en datamaskin, det vil si prosessor, minne og alle tilkoblede enheter, styres av et operativsystem. Dette operativsystemet skjuler detaljer om den underliggende maskinvaren for oss. Avhengig av hvilket operativsystem datamaskinen har, vil all tekst og alle verdier som sendes til System.out-objektet, komme ut i et bestemt område eller vindu på skjermen. Hvis vi for eksempel starter Java-programmene fra et MS-DOS-vindu, vil alle data

4 16 Kapittel 2 Grunnleggende programelementer som sendes til System.out-objektet komme ut i dette vinduet. Hvis vi bruker en Unix- eller GNU/Linux-maskin (også kjent som et POSIX-miljø), vil utskrift fra System.out-objektet komme ut i det kommandolinjevinduet vi jobber i. Ved bruk av et integrert utviklingsverktøy (eng. integrated development environment) vil utskriften fra System.out bli omdirigert til et eget utskriftsvindu i dette verktøyet. Slike verktøy er typisk menystyrte og gir tilgang til for eksempel kompilator og avluser (eng. debugger) i tillegg til en tekstbehandler. 2.2 Lokale variabler Små testprogrammer kan evaluere enkle numeriske uttrykk og skrive resultatet ut på skjermen umiddelbart. I de fleste tilfeller ønsker vi imidlertid å ta vare på en verdi for å bruke den senere i programmet. Da trenger vi en måte å lagre og hente frem igjen verdier på fra datamaskinens minne. Programmeringsspråk tilbyr variabler for dette formålet. En variabel (eng. variable) lar programmereren sette av plass i minnet til en verdi og gi denne plassen et navn. Dessuten har hver variabel en gitt datatype (eng. data type). En datatype (eller bare type) er definert ved et verdiområde og et sett av operasjoner. Typen brukes til å bestemme hvor mye plass verdien i variabelen vil trenge i minnet, og hvilke verdier som kan lagres i den. I dette avsnittet skal vi se på variabler som er definert inne i metoder. Disse kalles lokale variabler (eng. local variables). Deklarering av variabler I Java kan vi deklarere en heltallsvariabel som vist i Figur 2.2. Ved deklarasjon settes det av plass i minnet som betegnes av variabelen, og der en heltallsverdi kan lagres. Figur 2.2 Variabeldeklarasjon deklarasjon kommentar int antalldager; // antall dager i uken type variabelnavn Deklarasjonen starter med et nøkkelord (eng. keyword), int, som forteller at variabelen skal lagre verdier av heltallstype. Vi står ganske fritt til å velge navn, men navnet bør avspeile variabelens formål. Tegnet semikolon (;) avslutter deklarasjonen. Resten av linjen er en kommentar som forteller oss hva variabelen skal brukes til. Kommentarer starter med //, og alt som står etter det på samme linje, ignoreres av kompilatoren. Bruken av kommentarer i programmer er valgfrie, men det er en god regel å dokumentere variabler hvis formålet med dem ikke er innlysende ut fra navnet.

5 Avsnitt 2.2 Lokale variabler 17 Dersom man har flere variabler av samme type, kan man skrive dem i samme deklarasjon, med et komma (,) mellom variabelnavnene, for eksempel slik: int antalldager, antallmåneder; // antall dager i uken, måneder i året Dette er det samme som å skrive flere deklarasjonssetninger, som her: int antalldager; // antall dager i uken int antallmåneder; // antall måneder i året Noen eksempler i dette kapitlet utelater imidlertid slike kommentarer, fordi linjene er merket med et nummer (n) som så diskuteres i teksten. Variabelens formål vil da forklares i teksten eller fremgå av utskriftssetninger i programmet. Tilordning av verdi Etter å ha deklarert hvilken type variabelen skal ha, kan man tilordne den en verdi. Dette kalles å initialisere (eng. initialise) variabelen. I Java gjøres tilordning ved hjelp av operatoren =. For eksempel kan vi gi en heltallsvariabel verdien 7 med setningen antalldager = 7; Figur 2.3 Deklarasjon av variabel og tilordning av startverdi deklarasjon tilordning int antalldager = 7; type variabelnavn startverdi Program 2.2 illustrerer bruk av lokale heltallsvariabler. Etter deklarasjon og initialisering tar vi variabelen antalldager i bruk i linje (1). Vi kan også tilordne variabelen en verdi samtidig med at vi deklarerer den, slik Figur 2.3 og linje (2) i Program 2.2 viser. Hvis vi senere i programmet vil endre verdien i en variabel, er det bare å tilordne en ny verdi, slik det er gjort i linje (3). En lokal variabel må alltid gis en verdi før vi bruker den for eksempel i en utskriftssetning. Hvis vi prøver å fjerne linjen antalldager = 7; fra Program 2.2, vil kompilatoren gi en feilmelding. Kompilatoren vil ikke lage noen klassefil, og dermed kan vi ikke kjøre programmet.

6 18 Kapittel 2 Grunnleggende programelementer Program 2.2 Et enkelt program med lokale variabler class LokaleVariabler { public static void main(string[] args) { int antalldager; antalldager = 7; System.out.println("Antall dager i uken er " + antalldager); // (1) int antallmåneder = 12; // (2) System.out.println("Antall dager i året er " + antallmåneder); antallmåneder = 48; // (3) System.out.println("Antall måneder i en olympisk periode er " + antallmåneder); Kjøring av programmet: Antall dager i uken er 7 Antall dager i året er 12 Antall måneder i en olympisk periode er 48 Program 2.3 bruker flere lokale variabler, som tilordnes verdier fra litteraler og enkle uttrykk. Hver tilordning vil overskrive den nåværende verdien. Det er også viktig å merke seg at endringer ikke har tilbakevirkende kraft. Dersom vi for eksempel bruker en variabel a til å regne ut verdien av en annen variabel b, og vi endrer verdien til a, må vi passe på at også utregningen blir gjort på nytt. Ellers vil programmet gi tilsynelatende uriktige resultater. Dette skjer i linje (12) i Program 2.3, der vi, med vitende og vilje, har glemt å regne ut den avhengige variabelen (grunnflate) på nytt, etter at vi har endret en av variablene (bredde) som inngår i utregningen. Den siste utskriften vil være Grunnflaten av et rektangel med lengde 6 og bredde 5 er : 24 som viser at den siste endringen av variabelen bredde ikke får tilbakevirkende kraft på variabelen grunnflate. Vi har en logisk feil i programmet, slik at det ikke oppfører seg på den måten vi ønsker. Derfor blir ikke resultatet som forventet. Siste gang grunnflaten regnes ut (ved (10)), hadde de to variablene lengde og bredde verdiene 6 og 4, og dermed blir produktet 24. Når vi endrer en variabel, kan vi enten gi en ny verdi ved å skrive denne direkte i koden, slik som i linje (1), (2) og (11), eller vi kan tilordne den verdien av en annen variabel eller et annet uttrykk av samme type, slik som i linjene (5) og (10). I begge tilfeller blir verdien av uttrykket på høyresiden av = tilordnet til variabelen som står på venstre side. Figur 2.4 viser hvordan verdiene til de lokale variabler endrer seg etter hvert som Program 2.3 kjører. Grå bakgrunn markerer den verdien som er endret.

7 Avsnitt 2.2 Lokale variabler 19 Program 2.3 Endring av verdi i lokale variabler class Tilordning { public static void main(string[] args) { int lengde = 5; // (1) int bredde = 4; // (2) int grunnflate = lengde * bredde; // (3) System.out.println("Grunnflaten av et rektangel med lengde " + lengde + " og bredde " + bredde + " er : " + grunnflate); // (4) bredde = lengde; // (5) grunnflate = lengde * bredde; // (6) System.out.println("Grunnflaten av et rektangel med lengde " + lengde + " og bredde " + bredde + " er : " + grunnflate); // (7) lengde = 6; // (8) bredde = 4; // (9) grunnflate = lengde * bredde; // (10) bredde = 5; // (11) System.out.println("Grunnflaten av et rektangel med lengde " + lengde + " og bredde " + bredde + " er : " + grunnflate); // (12) Kjøring av programmet: Grunnflaten av et rektangel med lengde 5 og bredde 4 er : 20 Grunnflaten av et rektangel med lengde 5 og bredde 5 er : 25 Grunnflaten av et rektangel med lengde 6 og bredde 5 er : 24 Figur 2.4 Tilordning av verdier til variabler (Program 2.3) lengde (a) Etter (1) 5 lengde 5 bredde 5 grunnflate 20 (d) Etter (5) lengde 6 bredde 4 grunnflate 25 (g) Etter (9) lengde 5 bredde 4 (b) Etter (2) lengde (e) Etter (6) 5 bredde 5 grunnflate 25 lengde (h) Etter (10) 6 bredde 4 grunnflate 24 lengde 5 bredde 4 grunnflate 20 (c) Etter (3) lengde 6 bredde 5 grunnflate 25 (f) Etter (8) lengde 5 bredde 5 grunnflate 24 (i) Etter (11)

8 20 Kapittel 2 Grunnleggende programelementer Litteraler og konstanter Vi har sett i flere programeksempler at vi kan skrive en tallverdi direkte i kildekoden, som for eksempel i uttrykket 9+7 Her brukes litteraler fordi det er enkleste måte å beregne verdien av uttrykket på. I andre tilfeller brukes litteraler for å beskrive matematiske konstanter (for eksempel pi), en faktor det skal multipliseres med i et uttrykk (for eksempel en rentefot), eller en størrelse som angir maksimal kapasitet. Vi kan for eksempel ha et billettsystem der antallet seter er et fast tall som brukes flere steder. Hvis kinoen senere utvides slik at antallet seter økes, og vi må oppdatere billettsystemet vårt, må det gamle tallet erstattes med det nye mange steder i koden. Da er det en fordel å deklarere det faste tallet som en konstant. En konstant er en variabel som ikke kan endre verdi etter at den er initialisert. I Java deklarerer vi en konstant slik: final int ANTALL_DAGER_I_UKEN = 7; Her angir nøkkelordet final at denne variabelen ikke kan endres. Hvis vi prøver å gi denne variabelen en ny verdi senere i programmet, vil ikke kompilatoren godta dette. Det er vanlig å skrive navn på slike konstanter med store bokstaver. Navngivning Når vi velger navn på variablene våre, er det to ting å huske på: regler for hva som er gyldige navn i Java, og konvensjoner for hva man bør og ikke bør kalle en variabel. Følgende eksempler illustrerer dette: int agent007; // navn kan inneholde bokstaver og sifre //int 1001natt; // men siffer kan ikke stå først int antalltimer, varepris, forrigesum; // vanlige variabler // liten bokstav i første ord, stor bokstav i starten av neste final int DAGER_I_UKEN = 7, TIMER_I_UKEN = 7*24; // konstanter // understrek _ er tillatt (og vanlig for å skille mellom ord) int antallminutter, // Java skiller mellom små og store bokstaver antallminutter; // så dette er to forskjellige variabler! // nøkkelord som f.eks. int kan ikke brukes som navn Til sist noen tommelfingerregler for navngivning: Bruk navn som sier noe om formålet med variabelen (eller konstanten). Unngå navn med bare konsonanter. De er vanskelige å lese. Ikke bruk mer enn cirka 20 tegn i navnet. Nøkkelordene i Java er vist i Tabell B.1 på side 505.

9 Avsnitt 2.3 To primitive numeriske datatyper To primitive numeriske datatyper En datatype er definert ved et verdiområde og et sett av operasjoner. Verdiområdet bestemmer hvilke verdier en variabel av typen kan ha, og operasjonene bestemmer hva slags handlinger vi kan utføre med den. For eksempel kan vi ha en heltallstype med operasjonene addisjon, subtraksjon, multiplikasjon og divisjon. Mange programmeringsspråk tilbyr primitive datatyper. Blant disse finner vi ulike typer av heltall og flyttall (også kalt desimaltall), med forskjellige gyldighetsområder og presisjon. Dette er også tilfelle i Java, som tilbyr i alt seks ulike datatyper for heltall og desimaltall. Vi skal se på de to mest brukte i eksemplene fremover: int og double. Den første typen, int, har vi allerede brukt flere ganger. En variabel av denne typen kan holde et heltall mellom og En variabel av type double kan holde verdier fra cirka -1.7E+308 til cirka +1.7E+308, med 15 nøyaktige (signifikante) sifre. Kapittel 3 vil beskrive de andre primitive datatypene i Java. 2.4 Aritmetiske uttrykk og operatorer De fire vanligste regneoperasjonene på numeriske verdier, multiplikasjon, divisjon, addisjon og subtraksjon, er innebygd i alle moderne programmeringsspråk. Figur 2.5 illustrerer hvordan noen enkle uttrykk er bygd opp ved hjelp av en operator og en eller flere operander. En operator angir hvilken regneoperasjon som skal utføres. Hver operator tar en eller flere operander som argumenter, det vil si at verdiene til operandene brukes i utregningen for den valgte operasjonen. Figur 2.5 Operatorer og operander i aritmetiske uttrykk unær operator binær operator binær operator operand operander pris + pris * 0.23 operander operand operand binær operator Aritmetiske operatorer og evalueringsregler Operasjonene multiplikasjon (*), divisjon (/), addisjon (+) og subtraksjon (-) krever alle to operander, som hver må være en numerisk verdi eller et aritmetisk uttrykk. I tillegg finnes en modulo-operator (%) som beregner restleddet ved divisjon. Denne er også en binær operator, det vil si at den krever to operander. Det finnes også to unære operatorer, + (unær pluss) og - (unær minus), som bare tar én operand.

10 22 Kapittel 2 Grunnleggende programelementer Alle disse operatorene er definert for både heltall og desimaltall, slik at følgende uttrykk alle er gyldige i Java: som evalueres til / 3 som evalueres til / 3.0 som evalueres til / -2.0 som evalueres til 8.25 Vi merker oss her at resultatet av uttrykket blir av samme type som operandene. Dersom vi kombinerer numeriske verdier av forskjellig type i et aritmetisk uttrykk, vil alle verdiene bli konvertert til en felles type. Dette kalles typekonvertering. Noen ganger vil reglene i Java-språket selv sørge for at konverteringen blir utført (implisitt konvertering), mens vi andre ganger må selv angi i programkoden at en bestemt konvertering skal utføres (eksplisitt konvertering). Typekonvertering av primitive datatyper Selv om vi bruker samme operatornavn, for eksempel + i uttrykk som 4+5 og , vil en aritmetisk operator i Java alltid jobbe på uttrykk av samme type. Det vil si at det egentlig er flere operatorer med samme navn, for eksempel en addisjonsoperator som jobber på heltall av type int, en som jobber på flyttall av type double, osv. Heldigvis trenger vi ikke å tenke på dette når vi bruker disse operatorene i aritmetiske uttrykk, fordi reglene i Java automatisk vil konvertere alle operander til en passende type og deretter velge den riktige operatoren for denne typen. Vi har bare sett på to numeriske datatyper så langt: int og double. Verdimengden for disse er forskjellig. Datatypen int kan bare holde heltall, mens datatypen double kan holde flyttall og med et langt større spenn i verdier. Derfor sier vi at double er en bredere datatype (eng. broader datatype) enn int. Dersom vi bruker både heltall og flyttall i et uttrykk og for eksempel skriver , vil Java automatisk konvertere alle ledd her til flyttall før evalueringen starter. Java vil automatisk utvide (forfremme) alle verdier til å være av en felles type som er bred nok til å holde alle verdier som inngår i uttrykket. Tilsvarende vil Java automatisk utføre typekonvertering dersom man tilordner et uttrykk av en gitt type til en variabel som har en bredere type, for eksempel hvis man tilordner verdien av en heltallsvariabel til en flyttallsvariabel, slik som i linje (1): int antallheletimer = 10; double antalltimer = antallheletimer; // (1) Java vil først konvertere heltallet 10 til flyttallsverdien 10.0 (av type double) før tilordningen blir utført.

11 Avsnitt 2.4 Aritmetiske uttrykk og operatorer 23 Dersom vi tilordner en numerisk verdi av en gitt type til en variabel som har en type med et mindre definisjonsområde, risikerer vi å miste informasjon. Dette kan skje for eksempel hvis vi vil tilordne verdien av en flyttallsvariabel til en heltallsvariabel. Dersom verdien av flyttallsvariabelen har en desimaldel, kan denne ikke tas vare på av en heltallsvariabel. Derfor krever Java at vi eksplisitt sier at en slik konvertering skal utføres, som i følgende kodebit: double antalltimer = 37.5; int antallheletimer = (int) antalltimer; // (1) Dette gjøres ved å plassere den typen det skal konverteres til, inne i parenteser. Denne formen (typenavn) kalles eksplisitt typekonvertering (eng. casting). Hvis vi utelater den fra linje (1) ovenfor, vil ikke kompilatoren godta programmet. Presedens og assosiativitet til operatorer Rekkefølgen av evalueringen styres av operatorenes presedens, som angir en innbyrdes ordning mellom ulike operatorer. Presedensreglene definerer et hierarki av aritmetiske operatorer, der en operator på et høyere nivå alltid evalueres før en operator på et lavere nivå. Disse reglene avgjør hvilken operator som skal utføres først dersom det finnes to operatorer med forskjellig presedens som følger hverandre i det sammensatte uttrykket. Operatoren med høyest presedens utføres først. For eksempel vil * 2 bli evaluert til 4 + (5 * 2), deretter til og til slutt 14 fordi * har høyere presedens enn +. Vi har her brukt parenteser til å indikere rekkefølgen i evalueringen. Dersom vi ønsker en annen evalueringsrekkefølge enn det presedensreglene tilsier, kan vi overstyre disse ved hjelp av parenteser. Dersom vi i uttrykket ovenfor ønsker å utføre addisjonen først, må vi eksplisitt angi dette ved hjelp av parenteser: (4 + 5) * 2 Dette ville gitt resultatet 18. Tabell 2.1 viser presedensen til de aritmetiske operatorene vi har sett på til nå. Tabell 2.1 Presedens til aritmetiske operatorer Presedensnivå Type operator Operator høy unær +, - binær *, /, % lav binær +, - Alle operatorer har en assosiativitet som avgjør om de først vil bruke operanden til venstre eller høyre for seg i beregningen. Venstreassosiativitet medfører gruppering fra venstre mot høyre, for eksempel vil uttrykket tolkes som ((1 + 2) - 3) siden binære operatorer + og - har venstreassosiativitet. Høyreassosiativitet medfører gruppering fra høyre mot venstre. For

12 24 Kapittel 2 Grunnleggende programelementer eksempel vil uttrykket tolkes som (- (- 4)) (med resultat 4) siden unær operator - har høyreassosiativitet. Assosiativitetsregler brukes til å avgjøre hvilken operator som skal utføres først, dersom det er to operatorer med samme presedens etter hverandre i uttrykket. Multiplikasjon, divisjon og modulo er på samme nivå i presedenshierarkiet og har høyere presedens enn addisjon og subtraksjon. Derfor vil et uttrykk som 5 * 6 / 2 bli evaluert slik: ((5 * 6) / 2), deretter til (30 / 2) og til slutt 15. Heltalls- og flyttallsdivisjon De fleste aritmetiske operasjoner i Java gir det resultatet en ville forvente ut fra grunnleggende matematikkunnskaper og erfaring med bruk av en enkel lommekalkulator. Et unntak er en divisjon der både teller og nevner er heltallsuttrykk. Heltallsdivisjon gir alltid et heltall som svar, så hvis man for eksempel prøver å regne ut uttrykket 3/4 i et Java-program, vil man få resultatet 0, og ikke 0.75, slik en kalkulator ville gitt. Dersom minst én av operandene til divisjonsoperatoren er et flyttall, konverteres den andre automatisk til flyttall slik at resultatet også blir et flyttall. Dette kalles flyttallsdivisjon. Implisitt typekonvertering utføres også for modulo-operatoren. Program 2.4 illustrerer bruken av divisjons- og modulo-operatoren. Siste del av programmet viser hva som skjer dersom vi prøver å dividere med null. Merk forskjellen på heltalls- og flyttallsdivisjon. Deler vi et tall a på flyttallet 0.0, får vi henholdsvis verdiene Infinity og NaN (Not a Number) avhengig av om a selv har verdien 0.0 eller ikke. Heltallsdivisjon med 0 i nevneren gir en feilmelding, og deretter avsluttes programmet. Program 2.4 Test av divisjons- og modulo-operatoren for heltall og flyttall class Divisjon { public static void main(string args[]) { System.out.println("Heltallsdivisjon og modulo:"); System.out.println(" 3/2 = " + (3/2)); System.out.println(" 3/4 = " + (3/4)); System.out.println(" 3%2 = " + (3%2)); System.out.println("Flyttallsdivisjon og modulo:"); System.out.println(" 3.0/2.0 = " + (3.0/2.0)); System.out.println(" 3.0/4.0 = " + (3.0/4.0)); System.out.println(" 3.0%2.0 = " + (3.0%2.0)); System.out.println("Divisjon med null:"); System.out.println(" 2.0/0.0 = " + (2.0/0.0)); System.out.println(" 0.0/0.0 = " + (0.0/0.0)); System.out.println(" 2.0/0 = " + (2.0/0)); System.out.println(" 2/0 = " + (2/0));

13 It's now or never Flaming Star Suspious Minds Angel Avsnitt 2.5 Innlesing av numeriske verdier fra terminalen 25 Kjøring av programmet: Heltallsdivisjon og modulo: 3/2 = 1 3/4 = 0 3%2 = 1 Flyttallsdivisjon og modulo: 3.0/2.0 = /4.0 = %2.0 = 1.0 Divisjon med null: 2.0/0.0 = Infinity 0.0/0.0 = NaN 2.0/0 = Infinity Exception in thread "main" java.lang.arithmeticexception: / by zero at Divisjon.main(Divisjon.java:15) 2.5 Innlesing av numeriske verdier fra terminalen Java har ingen enkle setninger for å lese numeriske verdier fra terminalen. Derfor vil denne boken bruke en egendefinert klasse, Terminal, som forenkler innlesing. Klassen Terminal tilbyr to metoder, lesint() og lesdouble(), for innlesing av henholdsvis heltall og flyttall. For å bruke disse trenger man ikke vite noe om hvordan innlesingen faktisk skjer. Det er nok at man har kopiert kildekoden for Terminal-klassen til samme katalog som man vil kjøre eksempelprogrammene i, og at man har kompilert denne filen før man kjører noen av eksemplene. Figur 2.6 skisserer hovedtrekkene i innlesingsprosessen. Alle tegn som tastes inn på tastaturet, håndteres av Terminal-klassen. Kapittel 12 vil forklare hvordan denne klassen er implementert, men for å bruke Terminal-klassen er det nok å vite to ting: (1) Programmet vårt må kalle enten lesint() eller lesdouble() avhengig av om vi vil lese et heltall eller et flyttall, og (2) verdien som returneres fra dette kallet, må lagres i en variabel av riktig type. Dessuten må programmet på forhånd skrive ut en fornuftig ledetekst, slik at brukeren vet hva slags verdi som skal tastes inn. Figur 2.6 Innlesing fra terminal main() :HeltallsLeser lesint() Terminal Skjerm 1 2 Tastatur Enter-tasten trykkes

14 26 Kapittel 2 Grunnleggende programelementer Eksempel med innlesing av heltall For å teste Terminal-klassen lager vi et lite program som beregner arealet på et rektangel når lengden av sidene tastes inn av brukeren. Først vil vi løse dette problemet for rektangler der hver side er et heltall. Program 2.5 viser en slik løsning. Variabeldeklarasjoner gjøres på samme måte som tidligere. Dessuten bruker vi System.outobjektet til å skrive ut ledetekster slik at brukeren vet hvilke inndata programmet forventer. Nytt i eksemplet er metodekallet Terminal.lesInt() i linjene (1) og (2), som sørger for at brukeren kan taste inn et heltall for å angi henholdsvis lengden og bredden på rektangelet. Hvert kall returnerer et tall til programmet, som så tilordner verdien til en variabel av riktig type. Det er viktig å merke seg at Terminal-klassen kun kan lese én verdi per linje. Program 2.5 Innlesing av heltall fra terminalen class HeltallsLeser { public static void main(string[] args) { int lengde; int bredde; int grunnflate; System.out.println( "Oppgi lengden av rektangelet [heltall] :"); lengde = Terminal.lesInt(); // (1) System.out.println( "Oppgi bredden av rektangelet [heltall] :"); bredde = Terminal.lesInt(); // (2) grunnflate = lengde * bredde; System.out.println("Grunnflaten av et rektangel med lengde " + lengde + " og bredde " + bredde Eksempel med innlesing av flyttall Vi ser nå på samme problem som i forrige eksempel, men ønsker å kunne gi inn lengde og bredde av rektangelet som flyttall. Dette gjør programmet mer fleksibelt, fordi vi fremdeles kan gi heltall som inndata siden disse også er gyldige som flyttall. Merk at vi må angi desimaltegnet med "." (punktum) og ikke med "," (komma).

15 Avsnitt 2.5 Innlesing av numeriske verdier fra terminalen 27 Med flyttallsvariabler vil kildekoden se ut som i Program 2.6. Sammenlignet med forrige eksempel er variabeldeklarasjonen endret (type double istedenfor int), og vi kaller lesdouble()-metoden istedenfor lesint()-metoden. For å hjelpe brukeren har vi også endret ledetekstene slik at det går klart fram at flyttall forventes som inndata. Ellers gjør vi beregninger og lager utskrift som i Program 2.5. Program 2.6 Innlesing av flyttall fra terminalen class FlyttallsLeser { public static void main(string[] args) { double lengde; double bredde; double grunnflate; System.out.println( "Oppgi lengden av rektangelet [flyttall] :"); lengde = Terminal.lesDouble(); // (1) System.out.println( "Oppgi bredden av rektangelet [flyttall] :"); bredde = Terminal.lesDouble(); // (2) grunnflate = lengde * bredde; System.out.println("Grunnflaten av et rektangel med lengde " + lengde + " og bredde " + bredde + " er : " + grunnflate); Kjøring av programmet: Oppgi lengden av rektangelet [flyttall] : 15.5 Oppgi bredden av rektangelet [flyttall] : 4 Grunnflaten av et rektangel med lengde 15.5 og bredde 4.0 er : 62.0 En ting som kan være verdt å merke seg, er hva som skjer hvis man gir flyttall med litt flere desimaler som inndata til Program 2.6. Gir vi for eksempel 4.6 og 2.38 for lengde og bredde, vil programmet skrive ut som resultat. Med andre ord kan vi få en litt stygg utskrift med mange desimaler når vi jobber med flyttall i Java. Enkel feilhåndtering ved innlesing Ved innlesing av tall fra terminal i Program 2.5 og Program 2.6 er det to mulige feilkilder. For det første kan brukeren taste inn noe som ikke er et gyldig tall. For det andre kan det som tastes inn, være et negativt tall, noe som ikke gir mening i disse programmene. Dersom brukeren oppgir et flyttall under kjøring av Program 2.5, vil det skrives ut en feilmelding, og han må oppgi et nytt tall. Kontrollen av at inndata er et gyldig tall, er bygd inn i Terminal-klassen. Andre verdier, som strenger og enkle tegn (unntatt siffer), vil ikke godtas.

16 28 Kapittel 2 Grunnleggende programelementer Program 2.5 og Program 2.6 er derfor sikret at returverdien fra kall av lesint() og lesdouble() er henholdsvis et heltall og et flyttall. Terminal-klassen har derimot ingen mulighet for å sjekke at tallene som gis inn, er fornuftige ut fra det programmet skal bruke dem til. Det er derfor programmets oppgave å kontrollere dette. I våre enkle eksempler er en slik test utelatt med vilje for å gjøre kildekoden kortere, men dette er en logisk feil som for eksempel fører til at brukeren kan gi inn negative tall og få ut en negativ grunnflate for rektangelet. Et mer robust program ville først sjekket at alle gitte verdier var tillatt, og så gjentatt innlesingen inntil gyldig verdi ble gitt. Imidlertid har vi ikke lært de nødvendige mekanismer for å kontrollere en verdi mot en bestemt grense og for å gjenta en handling flere ganger. Derfor må en slik utvidelse vente inntil videre. 2.6 Sannhetsuttrykk I mange problemstillinger ønsker vi å utføre forskjellige handlinger under gitte forutsetninger. Vi tenker oss et (forenklet) lønnssystem som eksempel, der lønn skal beregnes på timebasis. Her vil ukelønnen til en ansatt variere med det antallet timer vedkommende har jobbet i inneværende uke. Det kan være en fast lønn for det som er avtalt som standard arbeidstid, og deretter en viss sats for hver time utover dette. Dersom man jobber mindre enn standard arbeidstid, vil man likevel få utbetalt den faste ukelønnen. I et reelt system vil nok lønnsberegning være mer komplisert, men for eksemplets skyld antar vi at systemet kan følge de enkle reglene som er skissert ovenfor. For å løse et slikt problem trenger vi en setning der vi kan stille opp ett eller flere kriterier som må være oppfylt, og i tillegg angi de handlingene som skal utføres i hvert tilfelle. En slik setning kalles en valgsetning. Andre problemstillinger kan kreve at programmet utfører én eller flere handlinger flere ganger. For eksempel vil man i et lønnssystem ha behov for å gjenta beregning av ukelønn for hver enkelt av de ansatte. Denne typen problem kan løses ved hjelp av en løkke, der vi kan gjenta én eller flere operasjoner et fast antall ganger eller så lenge et gitt kriterium er oppfylt. Valg- og repetisjonssetninger gir oss muligheten til å velge én eller flere handlinger. Disse setningene tilbyr kontrollflyt, det vil si at de gjør oss i stand til å styre utføringen i programmet, slik at vi ikke lenger er begrenset til å utføre bare sekvensielle handlinger. Før vi tar i bruk kontrollflyt, skal vi imidlertid se på grunnlaget for alle former av kontrollflyt: hvordan formulere betingelsene for å foreta et valg eller gjenta en handling. Sannhetsuttrykk Et sannhetsuttrykk har verdien sann eller usann. Derfor kan vi bruke denne formen for uttrykk til å styre kontrollflyten i et program, eller med andre ord styre hvilken del av programmet som skal utføres.

17 Avsnitt 2.6 Sannhetsuttrykk 29 Verdien av et sannhetsuttrykk kan man tilordne en boolsk variabel. Et slikt uttrykk kan kun ha sannhetsverdiene sann eller usann (på engelsk true eller false). I Java har boolske variabler typen boolean, og vi kan deklarere en boolsk (eller logisk) variabel slik: boolean erferdig = false; Her er verdien false en boolsk litteral. Boolske variabler i Java kan kun tilordnes verdien true eller false. Enkle sannhetsuttrykk Et enkelt sannhetsuttrykk består av en sammenligningsoperator og to operander, som kan være variabler, litteraler, konstanter eller andre uttrykk. For eksempel vil følgende uttrykk i Java antalltimer >= 37.5 evalueres til verdien true hvis verdien av variabelen antalltimer er større eller lik 37.5, og til verdien false ellers. Vi kan også sammenligne en numerisk variabel med en annen (det vil si at vi sammenligner verdiene deres). Hvis vi har definert to variabler, kalt antalltimer og ANTALL_FASTE_TIMER, vil uttrykket antalltimer >= ANTALL_FASTE_TIMER evalueres til verdien true hvis verdien av variabelen antalltimer er større eller lik verdien til ANTALL_FASTE_TIMER, og til verdien false ellers. Vi kan også ha aritmetiske uttrykk som operander i sannhetsuttrykk. Aritmetiske operatorer har høyere presedens enn sammenligningsoperatoren. Et eksempel på dette er antallkrone + antallmynt == antallkast der vi sammenligner summen av to variabler med verdien til en annen. Uttrykket ovenfor evalueres slik: ((antallkrone + antallmynt) == antallkast). Her er operatoren == testen på likhet, det vil si om begge operandene har samme verdi. Merk at denne operatoren skrives med to likhetstegn og uten mellomrom. En vanlig feil er å forveksle den med tilordningsoperatoren =. Java har flere sammenligningsoperatorer enn dem vi har diskutert ovenfor. En fullstendig liste er vist i Tabell 2.2.

18 30 Kapittel 2 Grunnleggende programelementer Tabell 2.2 Sammenligningsoperatorer i Java Operator Betydning == er lik!= er forskjellig fra < er mindre enn > er større enn <= er mindre eller lik >= er større eller lik Sammensatte sannhetsuttrykk Vi kan også kombinere flere enkle sannhetsuttrykk ved hjelp av logiske operatorer (også kalt boolske operatorer). Da får vi et sammensatt sannhetsuttrykk som består av to eller flere enkle sannhetsuttrykk kombinert med logiske operatorer. Tabell 2.3 viser de logiske operatorene i Java. Tabell 2.3 Logiske operatorer i Java Operator Betydning! Negasjon, som gir den motsatte boolske verdien av operanden som resultat. Det vil si at!true evalueres til false og!false evalueres til true. && Betinget OG, som gir resultatet true dersom begge operandene har verdien true, og verdien false ellers. Betinget ELLER, som gir resultatet true dersom minst én av operandene har verdien true, og verdien false ellers. De logiske operatorene har lavere presedens enn sammenligningsoperatorer, slik at uttrykket ukedag >= 6 ukedag == 3 blir beregnet slik: ((ukedag >= 6) (ukedag == 3)). Hvis vi antar at variabelen ukedag inneholder dagnummer i uken nummerert fra 1 for mandager, vil denne testen returnere verdien true for ukedagene onsdag, lørdag og søndag, og false ellers. Presedensen til de logiske operatorene er som følger: Negasjonsoperatoren har høyere presedens enn betinget OG, som igjen har høyere presedens enn betinget ELLER. Med andre ord vil uttrykket b1!b2 && b3 evalueres til b1 ((!b2) && b3)

19 Avsnitt 2.6 Sannhetsuttrykk 31 der parentesene viser utregningsrekkefølgen, med den innerste parentesen først. (Vi antar at b1, b2 og b3 alle er boolske variabler.) Assosiativitetssregler er som følger: Negasjonsoperatoren assosierer fra høyre mot venstre. Betinget OG og betinget ELLER assosierer begge fra venstre mot høyre. Derfor vil variabelen b2 ovenfor bli assosiert med!-operatoren, og uttrykket!b2 inngå som operand til &&-operatoren, som assosieres med to operander fra venstre mot høyre. Sammensatte sannhetsuttrykk evalueres fra venstre mot høyre. Legg merke til at beregningen av et sammensatt sannhetsuttrykk med operatorene && eller i Java vil stoppe så snart verdien av hele uttrykket er bestemt. Vi kaller dette kortsluttende eller forkortet beregning av sannhetsverdien (eng. short-circuit evaluation). For eksempel vil uttrykket (4 == 3) && (3 < 4) evalueres til false && (3 > 4). Deretter vil beregningen stoppe, fordi operatoren && (betinget OG) alltid vil gi false til svar dersom en av operatorene er false. Det er derfor ingen vits i å evaluere resten av uttrykket. Tilsvarende vil uttrykket (4 > 3) (5 < 4) evalueres til true (5 < 4). Deretter stoppes beregningen, fordi hele uttrykket må være sant når en av operandene til operatoren er true. De Morgans lover I noen tilfeller kan sammensatte sannhetsuttrykk være kompliserte. Da kan vi bruke De Morgans lover til å omforme slike uttrykk slik at de blir lettere å forstå. Dersom b1 og b2 begge er sannhetsutrykk, er det sammensatte uttrykket!(b1 && b2) ekvivalent med (!b1!b2) og!(b1 b2) ekvivalent med (!b1 &&!b2). Hvis vi for eksempel vil avgjøre om et heltall t ligger innenfor et gitt intervall med nedre grense a og øvre grense b, kan vi skrive dette som t >= a && t <= b, eller som!(t < a t > b), ved å bruke De Morgans andre lov. Begge disse uttrykkene vil bli evaluert til samme sannhetsverdi for alle verdier av a, b og t, og vi står derfor fritt til å velge den formen vi synes er enklest å forstå.

20 32 Kapittel 2 Grunnleggende programelementer 2.7 Kontrollflyt: valgsetninger Enkel valgsetning En enkel valgsetning lar programmet utføre en handling hvis en gitt betingelse er oppfylt. Denne betingelsen må gis som et sannhetsuttrykk. Er dette kriteriet ikke oppfylt, vil programmet gå videre med den første setningen etter valgsetningen. Java realiserer en enkel valgsetning ved hjelp av en if-setning, som vist i Figur 2.7. Den enkle setningen etter sannhetsuttrykket utføres hvis sannhetsuttrykket evalueres til true. Ellers fortsetter programmet med første setning etter valgsetningen. Figur 2.7 Enkel valgsetning sannhetsuttrykk if (antalltimer > 37.5) ukelønn = ukelønn + (antalltimer ) * 200.0; sanndel nøkkelord Figur 2.8 Utføring av en enkel valgsetning (start) Tester sannhetsuttrykk [er sann] [er usann] Utfører sanndel (slutt) Figur 2.8 viser utføring av en enkel valgsetning. Hvis sannhetsuttrykket er sant, utføres den betingede handlingen (sanndelen) før valgsetningen avsluttes. Hvis uttrykket derimot er usant, avsluttes valgsetningen direkte. Bruken av valgsetninger illustreres ved hjelp av enkle eksempler på lønnsberegning. Vi ønsker et program som regner ut ukelønnen for en ansatt, når basis ukelønn for en person som har jobbet 37.5 timer (eller mindre), er 5000 kroner. Deretter skal det betales 200 kroner for hver etterfølgende time. Program 2.7 bruker en enkel valgsetning til å løse dette problemet. Starten på programmet ligner på tidligere eksempler, med deklarasjon av variabler, utskrift av ledetekst og innlesing av et flyttall for antall timer arbeidet i inneværende uke. Deretter initialiseres variabelen for ukelønn til basislønnen i (1).

21 Avsnitt 2.7 Kontrollflyt: valgsetninger 33 Programmet må så legge til eventuell overtidsbetaling, hvis det er jobbet mer enn 37.5 timer. Derfor brukes en if-setning til å sjekke om det gitte antall timer overskrider vanlig arbeidstid. Dersom sannhetsuttrykket i linje (2) evalueres til true, utføres setningen i (3), som legger til overtidsbetaling. Deretter brukes System.out til å skrive ut resultatet. Program 2.7 Bruk av enkel valgsetning class Ukelonn1 { public static void main(string[] args) { double antalltimer; // antall timer arbeidet inneværende uke double ukelønn; // lønn utbetalt per uke System.out.println("Oppgi antall timer arbeidet [flyttall] :"); antalltimer = Terminal.lesDouble(); ukelønn = ; // (1) if (antalltimer > 37.5) // (2) ukelønn = ukelønn + (antalltimer ) * 200.0; // (3) System.out.println("Ukelønnen for " + antalltimer + " timer er " + ukelønn + " kroner"); // (4) Blokker med setninger I eksemplet ovenfor var det bare en enkel setning som skulle utføres hvis valgkriteriet var oppfylt (det vil si ble evaluert til true). Dersom handlingen hadde bestått av flere setninger, måtte vi ha plassert disse i en blokk. En blokk er en sammensatt setning og kan brukes alle steder der en enkel setning kan brukes. Starten av en blokk angis med { og slutten av en blokk med, slik Figur 2.9 viser. Figur 2.9 En blokk av setninger blokk starter if (antalltimer > 37.5) { overtid = antalltimer ; ukelønn += overtid * 200.0; sanndel blokk slutter

22 34 Kapittel 2 Grunnleggende programelementer Valgsetning med to alternativer Svært ofte har vi bruk for å velge mellom to prosesseringsalternativer, der programmet utfører det ene alternativet hvis den gitte betingelsen er sann, og det andre alternativet hvis den er usann. Java realiserer denne typen valg med en if-else-setning. Figur 2.10 viser et eksempel på en slik setning. Figur 2.10 Valgsetning med to alternativer nøkkelord sannhetsuttrykk sanndel usanndel nøkkelord Første del av en if-else-setning er den samme som for en enkel valgsetning. Sanndelen utføres dersom sannhetsutrykket er sant, og usanndelen utføres ellers. Nøkkelordet else innleder usanndelen. Utføringen av en if-else-setning er illustrert i Figur For en slik valgsetning må programmet utføre den ene av de betingende handlingene. Figur 2.11 Utføring av en valgsetning med to alternativer (start) Tester sannhetsuttrykk [er sann] Utfører usanndel [er usann] Utfører sanndel (slutt) Program 2.8 løser samme problem som Program 2.7. Deklarasjon av variabler og innlesing av antall timer gjør vi på tilsvarende måte som i Program 2.7. Deretter bruker vi en if-else-setning til å beregne ukelønnen, fordi det er to alternativer å velge mellom. Enten har personen jobbet 37.5 timer (eller mindre), som kvalifiserer for basis ukelønn (linje (2)), eller så har vedkommende jobbet mer og skal da også få betalt for overtid.

23 Avsnitt 2.7 Kontrollflyt: valgsetninger 35 Program 2.8 Valgsetning med to alternativer class Ukelonn2 { public static void main(string[] args) { double antalltimer; // antall timer arbeidet inneværende uke double ukelønn; // lønn utbetalt per uke System.out.println("Oppgi antall timer arbeidet [flyttall] :"); antalltimer = Terminal.lesDouble(); if (antalltimer <= 37.5) // (1) ukelønn = ; // (2) else // (3) ukelønn = (antalltimer ) * 200.0; // (4) System.out.println("Ukelønnen for " + antalltimer + " timer er " + ukelønn + " kroner"); // (5) Kaskadevalgsetning Vi kan også ha en ny if-setning som det andre alternativet i en valgsetning. Da får vi en valgsetning som kalles en kaskadevalgsetning. Figur 2.12 viser en slik valgssetning med flere valg. Her vil den andre if-setningen bli utført som én setning dersom det første sannhetsuttrykket, timelønn < 60.0, er usant. I så fall vil sannhetsuttrykk nummer to, timelønn < 320.0, evalueres, og en av handlingene under den andre valgsetningen vil bli utført. Figur 2.12 Kaskadevalgsetning

24 36 Kapittel 2 Grunnleggende programelementer Figur 2.13 viser utføring av en kaskadevalgsetning. Ved å la handlingen under usanndel 2 igjen være en ny valgsetning kan vi få så mange valg vi ønsker. Figur 2.13 Utføring av en kaskadevalgsetning (start) Tester sannhetsuttrykk 1 [er usann] Tester sannhetsuttrykk 2 Utfører usanndel 2 [er usann] [er sann] [er sann] Utfører sanndel 2 Utfører sanndel 1 (slutt) Program 2.9 viser bruken av en kaskadevalgsetning. Her evalueres først sannhetsuttrykket i linje (2). Hvis det ikke er sant, blir sannhetsuttrykket i linje (4) evaluert. Hvis det heller ikke er sant, utføres den setningen som står etter den siste else-setningen, på linje (7) i programmet. Program 2.9 Et program med flere valg class Flervalg { public static void main(string[] args) { double faktisklønn = ; // (1) double antattlønn; System.out.println("Oppgi antatt lønn [flyttall] :"); antattlønn = Terminal.lesDouble(); if (antattlønn > faktisklønn) // (2) System.out.println( "Antatt lønn er større enn faktisk lønn."); // (3) else if (antattlønn < faktisklønn) // (4) System.out.println( "Antatt lønn er mindre enn faktisk lønn."); // (5) else // (6)

25 Avsnitt 2.7 Kontrollflyt: valgsetninger 37 Test av alternativ 2: Oppgi antatt lønn [flyttall] : 6320 Antatt lønn er større enn faktisk lønn. Test av alternativ 3: Oppgi antatt lønn [flyttall] : 6000 Faktisk lønn er som forventet! Nøstede valgsetninger Man kan også nøste valgsetninger. Da inngår en ny valgsetning i en av eller begge handlingene i den ytterste valgsetningen. En valgsetning er en setning på like fot med andre typer setninger (som for eksempel tilordninger). De kan derfor nøstes i valgsetninger på samme måte som andre setninger. En nøstet valgsetning er altså en valgsetning der minst én av handlingene som kan bli utført, selv inneholder en valgsetning. Nøstede valgsetninger illustreres i Program 2.10, der den nøstede valgsetningen strekker seg fra og med linje (5) til og med linje (6). Dette eksemplet baserer seg på samme problemstilling som de foregående, men nå med det tillegget at personer som har jobbet mer enn 42 timer i en uke, får et ekstratillegg på 500 kroner på toppen av overtidsbetalingen. Merk at vi også må bruke blokknotasjon, {, rundt setningene i else-delen for den ytterste if-else-setningen fordi vi her har to setninger i usanndelen. I Program 2.10 strekker usanndelen seg fra linje (4) til (6). Sanndelen har bare én linje, (2). Program 2.10 Bruk av nøstet valgsetning class Ukelonn3 { public static void main(string[] args) { double antalltimer; // antall timer arbeidet inneværende uke double ukelønn; // lønn utbetalt per uke System.out.println("Oppgi antall timer arbeidet [flyttall] :"); antalltimer = Terminal.lesDouble(); if (antalltimer <= 37.5) // (1) ukelønn = ; // (2) else { // (3) ukelønn = (antalltimer ) * 200.0; // (4) if (antalltimer > 42.0) // (5) ukelønn = ukelønn ; // (6) System.out.println("Ukelønnen for " + antalltimer + " timer er " + ukelønn + " kroner"); // (7)

26 38 Kapittel 2 Grunnleggende programelementer To kjøringer av programmet er Oppgi antall timer arbeidet [flyttall] : 39.5 Ukelønnen for 39.5 timer er kroner og Oppgi antall timer arbeidet [flyttall] : 42.5 Ukelønnen for 42.5 timer er kroner 2.8 Kontrollflyt: løkker Et annet nyttig programelement gir muligheten for å gjenta en handling flere ganger. Et slikt element kalles en løkke eller en repetisjonssetning. Den eller de setninger som gjentas i løkken, kalles løkkekroppen. Her skal vi se på en repetisjon som styres av et sannhetsuttrykk, og der setningen(e) i løkkekroppen gjentas inntil dette uttrykket blir usant. Det tilsvarer at løkkekroppen blir utført så lenge den gitte betingelsen er oppfylt. Den betingelsen kalles ofte løkkebetingelse eller løkkevakt. Løkkebetingelsen må være et sannhetsuttrykk som evalueres til enten true eller false. Java tilbyr to slike former for repetisjoner: while og do-while. Forskjellen på disse ligger i når betingelsen for å utføre løkkekroppen skal testes. Hvilken av disse løkketypene man velger vil derfor avhenge av problemet som skal løses. I mange tilfeller kan man utforme likeverdige løsninger med begge disse løkketypene, og da blir valg av løkketype mer en personlig preferanse. Løkke med test før løkkekroppen I den første typen av løkker kommer testen før løkkekroppen utføres. Kodebiten i Figur 2.14 viser en while-løkke i Java som realiserer denne formen for repetisjon. Løkken innledes med nøkkelordet while før løkkebetingelsen. Deretter kommer løkkekroppen, i dette tilfellet en blokk, som skal utføres for hvert gjennomløp av løkken. Figur 2.14 Eksempel på while-løkke nøkkelord løkkebetingelse while (teller < 10) { sum = sum + teller; teller = teller + 1; løkkekropp

27 Avsnitt 2.8 Kontrollflyt: løkker 39 En viktig ting å merke seg når det gjelder løkker, er at det må være en handling i løkkekroppen som påvirker løkkebetingelsen slik at denne kan endre sannhetsverdi. Ellers risikerer vi nemlig en evig løkke, det vil si at programmet aldri får avsluttet repetisjonen fordi betingelsen forblir sann hele tiden. Figur 2.15 viser hvordan en while-løkke blir utført av programmet. Det starter med å evaluere løkkebetingelsen. Dersom dette sannhetsuttrykket er sant, utføres løkkekroppen. Etter dette går programmet tilbake igjen til løkkebetingelsen og gjentar testen av denne. Slik vil programmet fortsette å gå i løkke inntil betingelsen ikke lenger er oppfylt. Med while-setningen vil betingelsen testes før man (eventuelt) utfører løkkekroppen første gang. Det betyr at dersom betingelsen ikke er oppfylt når man kommer til løkken, vil ikke løkkekroppen bli utført i det hele tatt. Figur 2.15 Utføring av en while-løkke (start) Tester løkkebetingelse [er usann] [er sann] Utfører løkkekropp (slutt) Program 2.11 leser inn et heltall fra terminalen og bruker deretter en while-løkke til å beregne n! (n-fakultet). n! er en matematisk funksjon som beregner produktet av alle heltall fra 1 opp til og med n. For eksempel er 4! = 1 * 2 * 3 * 4. Linje (1) deklarerer en variabel (valgttall) for å holde tallverdien for n, som vi lar programmet lese inn i linje (5). Linjene (2) og (3) deklarerer og initialiserer hver sin heltallsvariabel for å holde henholdsvis neste heltall vi skal multiplisere med, og resultatet av alle multiplikasjonene vi har gjort så langt. Sistnevnte variabel (nfakultet) vil holde det endelige resultatet når beregningen av n! er ferdig. Løkketesten i (7) sjekker om det neste tallet i rekken er mindre eller lik det tallet brukeren har gitt for n. Hvis nåværende tall er mindre eller lik n, gjentas løkkekroppen, ellers går programmet videre til utskriften av n! i linje (10). Løkkekroppen vil gjentas inntil vi kommer til første tall større enn den gitte verdien for n, og da vil programmet ha multiplisert sammen alle heltallene fra og med 1 til og med n. Før vi gikk inn i løkken (linje (6)), sjekket vi om det gitte tallet var innenfor definisjonsområdet til n!. Dette er nødvendig fordi n! kun er definert for heltall større eller lik 1.