51
1 Enkel programmodell • Notatblokk Når vi behandler informasjon, så har vi behov for å notere ned relevante opplysninger underveis. Tilsvarende har programmer sine ”notater”, hvor både start-tilstanden og (del)resultatene ”noteres”. Nøkkelen til et ryddig program er ofte å strukturere disse notatene på en god måte. • Utførelsestrinn Utførelsestrinnene definerer hva som skal noteres ned av informasjon og hvilke beregninger som skal utføres. Utførelsestrinnene leser notatene og endrer dem. Utførelsestrinnene kan også introdusere nye, midlertidige notater, som siden fjernes. Globale notate - - - - - - - Lokale - - -

prosedyreorientert programmering

Embed Size (px)

Citation preview

Page 1: prosedyreorientert programmering

1

Enkel programmodell

• Notatblokk– Når vi behandler informasjon, så har vi behov

for å notere ned relevante opplysninger underveis.

– Tilsvarende har programmer sine ”notater”, hvor både start-tilstanden og (del)resultatene ”noteres”. Nøkkelen til et ryddig program er ofte å strukturere disse notatene på en god måte.

• Utførelsestrinn– Utførelsestrinnene definerer hva som skal noteres ned av

informasjon og hvilke beregninger som skal utføres.

– Utførelsestrinnene leser notatene og endrer dem.

– Utførelsestrinnene kan også introdusere nye, midlertidige notater, som siden fjernes.

Globale notater-------

Lokale---

Page 2: prosedyreorientert programmering

2

Eksempel:Finn minste element i en tabell

• Vi– Bruk to fingre: Den ene peker på det hittil minste elementet og den andre

peker på hvor langt vi er kommet.– Flytt den andre fingeren nedover i tabellen.– Dersom den andre peker på et tall som er mindre enn det den første

fingeren peker på, så flytt den første fingeren til der den andre peker.

• Programmet– Noter ned (en referanse til) tabellen, og to tall, som er indekser i tabellen.– Den ene indeksen settes til det 0, som er indeksen til det første elementet i

tabellen. Den andre indeksen løper fra 1 til siste mulige indeks (løkke).– Dersom den andre indeksen refererer til et tall som er mindre enn det den

første indeksen refererer til, så sett den første indeksen til den andre.– Når en er ferdig med alle tabellindeksene, så trengs ikke den andre

indeksen. Svaret, dvs. indeksen til det minste elementer, er igjen i den første.

Page 3: prosedyreorientert programmering

3

Program:Finn minste element i en tabell

int[] array = {1, 2, 3, 4, 3, 6, 8, -1, 0, 10};int indexOfSmallest = 0, currentIndex = 1;while (currentIndex < array.length) { if (array[currentIndex] < array[indexOfSmallest]) { indexOfSmallest = currentIndex; } currentIndex = currentIndex + 1;

} - int[] array =- indexOfSmallest = 0 - currentIndex = 1

1 2 3 4 3 6 8 -1 0 10

- int[] array =- indexOfSmallest = 0 - currentIndex = 7

1 2 3 4 3 6 8 -1 0 10 #7

0 1 2 3 4 5 6 7 8 9

0 1 2 3 4 5 6 7 8 9

- int[] array =- indexOfSmallest = 7 - currentIndex = 7

1 2 3 4 3 6 8 -1 0 10 0 1 2 3 4 5 6 7 8 9

1

1

2

34

2

- int[] array =- indexOfSmallest = 7 - currentIndex = 8

1 2 3 4 3 6 8 -1 0 108

0 1 2 3 4 5 6 7 8 9

#73

#74

Page 4: prosedyreorientert programmering

4

Prøv med en Scrapbook

Page 5: prosedyreorientert programmering

5

Program:Finn minste element i en tabell

Page 6: prosedyreorientert programmering

6

Refleksjoner

• Fra manuell til mekanisk utførelse– På et overordnet nivå, så er programmet likt den manuelle metoden.– Mange detaljer må fylles inn, når en går fra manuell til programmert

mekanisk utførelse. F.eks. tilsvarer en finger en indeks av typen int.– Det lurt å vite hvordan det gjøres manuelt før en programmerer.

• Resultat i form av utskrift– Å få resultatet skrevet ut er nyttig for å se om resultatet er riktig. Men skal

resultatet bearbeides av andre deler av programmet er det bedre å skrive koden som en separat funksjon/metode, som returnerer en verdi.

• Scrapbook vs. ordentlig program– En Scrapbook er grei for å teste Java-snutter, f.eks. for å lære hvordan

spesifikke Java-funksjoner virker. Prøv f.eks. å se verdien til ”Hallvard”.substring(1, 4)

– Skal en skrive mer kode enn i eksemplet, er det mer praktisk å lage en Java-klasse med et hovedprogram.

Page 7: prosedyreorientert programmering

7

Elementer i prosedyreorienterte programmeringspråk

• Uttrykk/beregninger– de minste utførelsesenhetene

• Data og datatyper– materialet som utførelsestrinn bearbeider– både variabler og uttrykk har en datatype, som bestemmer hva som er lov å gjøre med det– primitive og sammensatte datatyper

• Variabeldeklarasjoner– strukturen og innhold til notatene– variabeldeklarasjoner definerer navn og type til variabler

• Kall til funksjoner/metoder– bruk av eksisterende kode

• Kontrollstrukturer– sekvenser– alternativer (if, switch/case) og repetisjoner (while, for)

• Egendefinerte funksjoner/metoder– parametre, parameteroverføring og returverdi

• Hovedprogram– globale variabler og kjøring av programkoden

Stort settrepetisjon

Page 8: prosedyreorientert programmering

8

Datatyper

• Alle verdier, konstanter og uttrykk som utføres har en såkalt datatype, som bestemmer hva en kan gjøre med verdien– sannhetsverdiene (boolean), sann (true) og usann (false)

– heltall (int/integer), f.eks. -123, 0, 1, 314

– desimaltall (float/double) , f.eks. -123d, 0.0, 3.1415926535

– tegn (char/character), f.eks. ’1’, ’ ’, ’\’’

– tekst (string): ”Hallvard”, ”\””

– enkle tabeller: {1, 2, 3} og {”en”, ”to”, tre”}

– fler-dimensjonale tabeller: {{1, 2, 3}, {4, 5, 6}}

Page 9: prosedyreorientert programmering

11

Uttrykk/beregninger• Den minste utførelsesenheten kalles gjerne uttrykk (eng:

expression)– Konstanter utgjør de enkleste uttrykkene,

f.eks. tallet 1, tegnet ’1’ og teksten ”1”

• Når et uttrykk utføres el. beregnes (eng: evaluation) blir resultatet en verdi som kan bli brukt i utførelsen av et større uttrykk

– Mindre uttrykk settes sammen til større vha. operatorer:2*2, 1!=2, ”objekt”+”orientering”

– Uttrykk utføres ved at deluttrykkene utføres først, deretter brukes operatorene på delverdiene:1+2!=3 => 3 != 3 => false

– Operatorer har prioritet, og paranteser brukes for å overstyre:1+2*3 => 1 + 6 => 7, mens (1+2)*3 => 3 * 3 => 9

• Datypen til et uttrykk kan avledes av operatorene og operandene/deluttrykkene

Page 10: prosedyreorientert programmering

12

Operatorer og operander

• Ulike operatorer krever ulike typer operander og gir ulike typer som resultat– Logiske operatorer (&&, || og !) krever sannhetsverdier som operander

og gir sannhetsverdier som resultat.– Alle typer kan sjekkes for likhet med == og !=. Resultatet er en

sannhetsverdi.– Tall og tegn kan sammenlignes med >, <, >= og <= og gir en

sannhetsverdi– Matematiske operatorer, som +, -, *, / kan brukes på alle tall og gir et

tallresultat– I Java kan + brukes på tekst, f.eks. ”1”+”1” og gir en ny tekst (”11”)– En kan hente ut verdier fra en tabell med []:{1,2,3}[1] => 2

• Selv om en i Java kan definere nye (data)typer, kan en ikke (re)definere operatorer (slik en delvis kan i C++)

Page 11: prosedyreorientert programmering

13

Variabeldeklarasjoner• For å kunne (gjen)bruke verdier fra delberegninger, kan en

bruke variabler– pi=3.14, r=2, omkrets=2*pi*r // tilordninger– nyttig for å gjøre koden ryddigere og kortere

• I mange språk må variabler og datatypen deklareres før den brukes– double pi; // deklarasjon– double pi=3.14 // deklarasjon og initialisering

• En deklarasjon utvider et notatark med et nytt navn• Variabler kan brukes i uttrykk (omtrent som i formler), og

står for verdien de har idet verdien til uttrykket beregnes– pi=3.14; omkrets=2*pi // omkrets er nå 6.28– pi=3 // omkrets er fortsatt 6.28– omkrets=2*pi // omkrets er 6

Page 12: prosedyreorientert programmering

14

Hvorfor må variabler deklareres?

• Datatypen til en verdi bestemmer hva en kan gjøre med den, f.eks. hvilke operatorer den kan være operand for

– <boolean> && <boolean> er lov, men ikke <int> && <int>

• Ved å deklarere typen til en variabel på forhånd, kan en (til en viss grad) sjekke at variabelen brukes på riktig måte– pi * radius * radius ser greit ut, men kun dersom pi og radius er tall– En kan likevel ikke sjekke alt: int n=0; k=1/n; // deling på 0!

• Datatyper og sjekking av lovlige operasjoner blir enda viktigere når en bruker tabeller (og objekter):– int[] tall = {1, 2, 3};

int antall = tall.length;int verdi = tall[0];

• Noen programmeringsspråkkrever ikke deklarasjoner

– praktisk, men gir lett flere feil i lengden

.length og [] er kun lovfordi tall-variabelener deklarert som en tabell

Page 13: prosedyreorientert programmering

15

Tilordninger• En tilordning endrer verdien til en variabel:

– n = 3– sum = sum + n

• En deklarasjon med initialisering tilsvarer en deklarasjon med umiddelbar tilordning– int n = 3– int n; n = 3

• Tilordninger brukes typisk til å– oppdatere øke en teller, løpende sum, etc.

i = i + 1;i += 1;i++;

– initialisere på et (senere) tidspunkt, når verdien er klar, f.eks. avhengig av en betingelseint min;if (i < j) min = i; else min = j;

• Vanligvis ønsker en å redusere antall tilordninger,for å unngå at

– variabler ikke er initialisert– endrer bruk over tid (gjenbruk av variable for annet formål)

Page 14: prosedyreorientert programmering

16

Tabeller

• Tabeller holder på en rekke verdier av samme type

• Deklarasjon:– <elementtype>[] <variabelnavn>, f.eks. int[] tabell;– <elementtype> <variabelnavn>[], f.eks. int tabell[];

• Bruk– Uthenting av element:

<tabellverdi>[<indeks>], f.eks. tabell[i]– Tilordning til nytt element:

<tabellverdi>[<indeks>] = <ny verdi>, f.eks.tabell[i] = tabell[i+1];

Page 15: prosedyreorientert programmering

17

Tabeller

• I Java (og C/C++) starter indekser på 0– Minste indeks er 0, største lovlige indeks er tabellens lengde – 1– tabell[0]; // første element– tabell[tabell.length - 1]; // greit– // gir feil ved utførelsetabell[tabell.length];

• Tabellvariabler bør initialiseres når de deklareres:– // {,,,} kun lov ved init.int[] tabell = {1, 2, 3};

– // tabell med 100 0’er int[] tabell = new int[100];

Page 16: prosedyreorientert programmering

18

Tabeller

• Tabeller kan ikke endre størrelse– int[] tabell = {1, 2, 3, 4};int antall = tabell.length; // 4

• Men tabellvariabler kan endres til å referere til annen tabell, med annen lengde– int tabell[] = {1, 2, 3, 4};– tabell.length == 4 // sant/true!– tabell = new int[50];– tabell.length == 4 // usant/false!– tabell.length == 50 // sant/true!

Page 17: prosedyreorientert programmering

19

Tabeller

• Kopiering fra en tabell til en annen– int t1[] = {1, 2, 3};– int t2[] = new int[6];– System.arraycopy(t1, 0, t2, 0, 3);– System.arraycopy(t1, 0, t2, 3, 3);

1 2 3

0 0 0 0 0 0

0 0 01 2 3

1 2 31 2 3

t1t2t2t2

Page 18: prosedyreorientert programmering

20

Tabeller forts.

• Flere variabler kan referere til samme tabell (se animasjon)– int[] tabell1 = {1,2,3};

int[] tabell2 = tabell1;– Hva skjer når den ene endres?– tabell1[1] = 0;– Hva er tabell2[1] nå?

• Når flere variabler refererer til samme tabell, vil endringer kunne skje fra flere ”kanter”

• Skillet mellom referanser og objektet selv, er sentralt innen objekt-orientering!– Verdien til en variabel er en referanse til et objekt– Endringer på et objekt er synlig gjennom alle referanser til det– En må ekplisitt lage kopier av objekter, for å unngå dette

1

0

2

1

3

2tabell1

tabell2

0

Page 19: prosedyreorientert programmering

21

Funksjonskall• Kall til funksjoner brukes for å utnytte kode som allerede er skrevet

(ordet ”metode” brukes om funksjoner i OO-språk)• I Java er det to syntaksvarianter:

– <klasse>.<navn>(<arg1>, ..., <argN>); f.eks.Math.sqrt(-1);

– <objektreferanse>.<navn>(<arg1>, ..., <argN>); f.eks.tekst.length();

• En funksjon tar imot 0 eller flere argumenter– Det må være riktig antall <arg>-uttrykk (Java 1.5 tillater såkalte varargs, dvs. n+ argumenter)– <arg>-uttrykkene må ha riktige datatyper (Java konverterer noen datatyper automatisk)

• Ved utførelse av et funksjonskall, utføres først hvert <arg>- deluttrykk og deretter kalles funksjonen med resultatene

• Funksjoner som returnerer en verdi/objektreferanse kan brukes som et uttrykk eller del av et uttrykk

– String navn = ”Hallvard Trætteberg”;– String fornavn = navn.substring(0, 8);– char initial = Character.toLowerCase(navn.charAt(0));

• Datatypen til funksjonskallet er lik typen til returverdien

Page 20: prosedyreorientert programmering

22

Kontrollstrukturer• Uttrykk har en implisitt kontrollstruktur

– Et uttrykk utføres innenifra, først utføres deluttrykkene, deretter utføres uttrykket utenfor, til uttrykket som helhet er utført

– Ved bruk av && og || vil utførelsen avbrytes ved hhv. usann/false og sann/true

• Setninger utføres normalt i sekvens• Betingede sekvenser kan angis med if/else:

– if (<test>) { <sann gren>} else { <usann gren>;}

• Repeterende sekvenser angis med while og for:– while (<test>) {

<setning1, setning2, ..., setningN>}

– for (<init>; <test>; <steg>) { < setning1, setning2, ..., setningN>}

Page 21: prosedyreorientert programmering

23

if/else• if/else brukes for å angi at noe kun skal utføres i

bestemte tilfeller• en if/else-setning har tre deler

– test-del: if (<test>)– en sann gren: <setning1> eller { <sekvens1> }– en usann gren: else <setning2> eller else { <sekvens2> }

• Eksempel:– int n = ..., m = ..., min;

if (n < m) {min = n;

} else {min = m;

}

• <test> er hvilket som helst uttrykk som gir en sannhetsverdi som resultat og <setning1>/<sekvens1> utføres dersom <test> gir sann, ellers utføres <setning2>/<sekvens2>

Page 22: prosedyreorientert programmering

24

if/else• Den usanne grenen kan utelates

– int n = ..., m = ..., min = n;if (m < n) {

min = m;}

• En ny if kan kombineres med else-delen, slik at én av mange alternativer kan velges– if (n < m) {

min = n;} else if (n == m) {

// ingenting skjer her} else {

min = m;}

• Det finnes også en if-aktig operator, som brukes i uttrykk:– <test> ? <sant deluttrykk> : <usant deluttrykk>, f.eks.

int min = (n < m ? n : m);– Som med if/else er det kun den relevante delen som utføres– Bør kun brukes når deluttrykkene er enkle

Page 23: prosedyreorientert programmering

25

while• Med while (og for) kan en eller flere setninger utføres

så lenge en betingelse er sann• En while-setning har to deler:

– test-del: while (<test>)– repeterende del: <setning> eller { <sekvens> }

• Den repeterende delen utføres om og om igjen, så lenge <test> gir sann. Merk at <test> utføres først og deretter etter, inntil den blir usann

• Eksempel:– int fakultet = 1, i = 1;

while (i < 10) {fakultet = fakultet * i;

i++; // samme som i = i + 1}

• Hva skjer dersom <test> aldri blir usann, f.eks. dersom vi glemmer å øke telleren? Evig løkke!

Page 24: prosedyreorientert programmering

26

for• for-setningen utvider test-delen av while-

setningen, med en init-del og en steg-del:– init-, test- og steg-del: for (<init-setning>;<test>;<steg-setning>)– repeterende del: <setning> eller { <sekvens> }

• Først utføres <init-setning> én gang. Deretter utføres den repeterende delen etterfulgt av <steg-setning> om og om igjen, så lenge <test> gir sann.

• Eksempel:– int fakultet = 1;

for (int i = 1; i < 10; i++) {fakultet = fakultet * i;

}

• Fordelen med for er at det er lettere å huske på å ta med steg-delen og dermed unngå evig løkke.

Page 25: prosedyreorientert programmering

27

break

• Det er noen ganger nødvendig å avbryte en while- eller for-setning

• Nøkkelordet break gjør at repetisjonen avbrytes og utførelsen fortsetter etter hele while- eller for-setningen

• Eksempel på break:– int tabell[] = {2, 1, 0, -1, 0, 1, 2};

int sum = 0, i = 0;while (i < tabell.length) { if (tabell[i] < 0) { break; } sum = sum + tabell[i]; i++;}

• Hva blir sum til slutt?

Page 26: prosedyreorientert programmering

28

continue• Nøkkelordet continue brukes for hoppe til slutten av løkka og

fortsette med steg- og test-delen og evt. en ny repetisjon• Eksempel på continue:

– int tabell[] = {2, 1, 0, -1, 0, 1, 2}, sum = 0;for (int i = 0; i < tabell.length; i++) { if (tabell[i] < 0) { continue; } sum = sum + tabell[i];}

• Hva blir sum?• continue kan brukes i en while-setning, men det er sjelden riktig

siden det da er lett å hoppe over steg-delen:– while (i < tabell.length) {

if (tabell[i] < 0) { continue; } sum = sum + tabell[i]; i++;}

• Hva skjer her?

Page 27: prosedyreorientert programmering

29

Oppsummering kontrollstrukturer

• sekvens:<setning1>;<setning2>; ...;<setningN>

• betinget utførelse:if (<test>)

<setning>;

• alternative setninger:if (<test>)

<setning1>; else if (<test2>)

<setning2>; else

<setning3>;

• repetisjon og avbrytelse:while (<test>){

...

...break;...

}

for (<init>;<test>;<steg>){......continue;...

}

?

???

Page 28: prosedyreorientert programmering

30

Iterasjon overtabell og String

• Iterasjon over elementene i en tabell:– for (int i = 0; i < tabell.length; i++) {

<gjør noe med tabell[i] her>}

• Iterasjon over tegnene i en String:– for (int i = 0; i < string.length(); i++) {

char c = string.charAt(i);<gjør noe med c her>

}

Page 29: prosedyreorientert programmering

31

Iterasjon over inntastede linjer med tekst

// lag en Scanner som leser fra konsollet// (egentlig java.util.Scanner) Scanner sc = new Scanner(System.in);// sørg for at den leser hele linjersc.useDelimiter(”\n”);while (sc.hasNext ()) {

// les neste linje og// fjern blanke tegn først og sistString s = sc.next().trim();// avslutt dersom linja er tomif (s.length() == 0) { break;}<gjør noe med s her>

}

Page 30: prosedyreorientert programmering

32

Iterasjon over liste med tall, adskilt med blanke tegn

// lag en Skanner som leser fra konsollet// (egentlig java.util.Scanner)Scanner sc = new Scanner(System.in);// fortsett så lenge det er flere tall// sc.hasNextInt() gir false når den // finner et ugyldig tall,// f.eks. punktum eller bokstaverwhile (sc.hasNextInt()) {

// les neste intint i = sc.nextInt();<gjør noe med i her>

}

Page 31: prosedyreorientert programmering

33

Egendefinerte funksjoner

• Funksjoner lar en dele koden opp i enheter– hver funksjon har en spesifikk oppgave– fra et sett parametre beregnes et resultat– parametre gjør funksjonene generelle og gjenbrukbare

• En funksjonsdefinisjon har essensielt tre deler:– returtype: typen til verdien som beregnes og returneres (med return)– parameterlista: typen (og navnene) til verdiene som kreves i kallet– koden som utgjør beregningen

• Funksjon sett utenifra:– parameterlista bestemmer hvilke argumenter kallet må inneholde– returtypen angir typen til funksjonskallet brukt i et uttrykk– eksempel: int sum(int n1, int n2) definerer en funksjon ved navn sum,

som tar to int-parametre og returnerer en int

Page 32: prosedyreorientert programmering

34

Egendefinerte funksjoner

• Funksjon sett innenifra:– parameterlista fungerer som variabeldeklarasjoner ift.

funksjonskoden– funksjonskoden forholder seg kun til parametrene og

”ser” ingen andre variabler– returtypen angir hva som må returneres med return-

nøkkelordet

• Eksempel:– int sum(int n1, int n2){

return n1 + n2;// n1 og n2 refererer til parametrene

}

Page 33: prosedyreorientert programmering

35

Egendefinerte funksjoner

• Eksempel:– int sum(int n1, int n2){

return n1 + n2;}

– int minus(int n1, int n2){return n1 – n2;

}– sum(1, minus(3, 4))

=> 0

• Trinnvis utførelse– sum(1, minus(3, 4))

• 1• minus(3, 4)

– int n1 = 3, n2 = 4;– return n1 – n2 => -1

• int n1 = 1, n2 = -1;• return n1 + n2 => 0

Page 34: prosedyreorientert programmering

36

Egendefinerte funksjoner

• Eksempel:– int sum(int n1, int n2)

{return n1 + n2;

}– sum(

sum(1, 2),sum(3, 4))

=> 10

• Trinnvis utførelse– sum( sum(1, 2),

sum(3, 4))

• sum(1, 2)– int n1 = 1, n2 = 2;– return n1 + n2 => 3

• sum(3, 4)– int n1 = 3, n2 = 4;– return n1 + n2 => 7

• int n1 = 3, n2 = 7;• return n1 + n2 => 10

Page 35: prosedyreorientert programmering

37

Egendefinerte funksjoner

• Eksempel:– int sum(int n1, int n2){

return n1 + n2;}

– int minus(int n1, int n2){return n1 – n2;

}– int suminus(int n1, int n2,

int n3){int n4 = sum(n1,

n2);int n5 = minus(n4,

n3);return n5;

}– suminus(1, 2, 3)

=> 0

• Trinnvis utførelse– suminus(1, 2, 3)

• int n1 = 1, n2 = 2, n3 = 3;• int n4 = sum(n1, n2)

– int n1 = 1, n2 = 2– return n1 + n2 => 3

• int n5 = minus(n4, n3)– int n1 = 3, n2 = 3;– return n1 – n2 => 0

• return n5 => 0

Page 36: prosedyreorientert programmering

38

Globale variabler

• Variabler (lokale) inni funksjoner lever like lenge som funksjonene er aktive– de dukker opp når funksjonen kalles– de ”lever” så lenge funksjonen er aktiv– de forsvinner når funksjonen returnerer

• Globale variabler lever like lenge som hele programmet– de dukker opp når programmet starter– de ”lever” så lenge programmet er aktivt– de forsvinner først når programmet avslutter– kan endres av alle kode, også av koden inni egendefinerte

funksjoner!

Page 37: prosedyreorientert programmering

39

Globale variabler

• Funksjoner kan endre globale variabler som en såkalt ”side-effekt”

• Eksempel:– int i = 5;void pluss(int n) {

i = i + n; // endre global variabel}pluss(i); // i = 10pluss(-i); // i = 0

• Det er ikke uvanlig å bruke globale variabler, men en skal være forsiktig med side-effekter

Page 38: prosedyreorientert programmering

40

Hovedprogram

• Et prosedyreorientert Java-program inneholder– globale variabler

• finnes i JSP, men ikke i TDT4110

• i Java har disse static foran

– egendefinerte funksjoner• i JSP ligger disse inni <%! ... %>• i Java har disse static foran

– hovedprogram eller oppstartsfunksjon• i JSP er dette koden inni <% ... %>• i Java brukes main-funksjonen ved oppstart

Page 39: prosedyreorientert programmering

41

Eksempel på hovedprogrampackage eksempler;

public class Teller1 {

static int teller = 0; static void økTeller(int n) { teller = teller + n; } static void printTeller() { System.out.println("Telleren er: " + teller); }

public static void main(String[] args) { printTeller(); for (int i = 0; i < args.length; i++) { økTeller(Integer.valueOf(args[i])); printTeller(); } }}

global variabel

globalemetoder

klassepakke

hovedprogram

Page 40: prosedyreorientert programmering

42

Notatark – levetid og synlighet

• Levetid– Notater har ulik levetid. Noen er globale, dvs. med

levetid tilsvarende programmet, andre er temporære.

– Tenk på notatene som lag med ark, evt. ark medgul-lapper på, som legges på og fjernes etter hvertsom programmet utføres.

• Synlighet– Selv om et notatark/gul-lapp finnes, kan ikke koden som kjører

alltid se innholdet eller endre det.

– Synligheten til et notatark definerer når innholdet kan leses og endres.

– Tenk på det som at nye ark kan dekke over eksisterende, slik at kun noen ark er tilgjengelige.

Globale notater-------

Lokale---

Page 41: prosedyreorientert programmering

43

Hver klasse har hvert sitt ark

Teller1- int teller =- void økTeller()- void printTeller()- void main()

System- PrintStream out =- void arraycopy(...)

package eksempler;

public class Teller1 { static int teller = 0; static void økTeller(int n) { … teller … } static void printTeller() { … teller … } public static void main(String[] args) { … økTeller … printTeller … }}

package eksempler;

public class Teller2 { static int teller = 0; static void økTeller(int n) { … teller … } static void printTeller() { … teller … } public static void main(String[] args) { … økTeller … printTeller … }}

Teller2- int teller =- void økTeller()- void printTeller()- void main()

Page 42: prosedyreorientert programmering

44

Klasser kan referere til hverandre

Teller1- int teller =- void økTeller()- void printTeller()- void main()

System- PrintStream out =- void arraycopy(...)

Teller2- void main()

package eksempler;

public class Teller1 { static int teller = 0; static void økTeller(int n) { … teller … } static void printTeller() { … teller … } public static void main(String[] args) { … økTeller … printTeller … }}

package eksempler;

public class Teller2 { public static void main(String[] args) { … Teller1.økTeller … Teller1.printTeller …

}}

Page 43: prosedyreorientert programmering

45

Enn viss... ?

Teller1- int teller =- void økTeller()- void printTeller()- void main()

System- PrintStream out =- void arraycopy(...)

package eksempler;

public class Teller1 { static int teller = 0; static void økTeller(int n) { … teller … } static void printTeller() { … teller … } public static void main(String[] args) { … økTeller … printTeller … }}

package eksempler;

public class Teller2 { static int teller = 0; static void økTeller(int n) { … teller … } static void printTeller() { … teller … } public static void main(String[] args) { … Teller1.økTeller … printTeller … }}

Teller2- int teller =- void økTeller()- void printTeller()- void main()

Page 44: prosedyreorientert programmering

46

Programklasse:Finn minste element i en tabell

public class Example1 {

static int findIndexOfSmallest(int array[]) { int indexOfSmallest = 0, currentIndex = 1; while (currentIndex < array.length) { if (array[currentIndex] < array[indexOfSmallest]) { indexOfSmallest = currentIndex; } currentIndex = currentIndex + 1; } return indexOfSmallest; }

static int[] testArray = {1, 2, 3, 4, 3, 6, 8, -1, 0};

public static void main(String[] args) { System.out.printf("Index of smallest is %d", findIndexOfSmallest(testArray)); }}

Page 45: prosedyreorientert programmering

47

Programklasse: Example1

• En klasse definerer innholdet til ett ark, med global levetid(vi skal siden komme tilbake til klasser og dynamiske ark)– System-klassen/arket er forhåndsdefinert i Java– Example1-klassen har vi skrevet

• En klasse definerer (navnene som er markert som static)– attributter/variabler, som er navngitte data som noteres på arket– metoder, som er navngitt kode som kan kalles som en funksjon

• public static void main(String[] args)– metode som tar inn en String-tabell (String[]) og ikke returnerer noe (void)– main-metoden kalles når klassen kjøres som et program, her brukt for å teste findIndexOfSmallest

public class Example1 {

static int findIndexOfSmallest(int array[]) { int indexOfSmallest = 0, currentIndex = 1; … } static int[] testArray = {1, 2, 3, 4, 3, 6, 8, -1, 0};

public static void main(String[] args) { System.out.printf("Index of smallest is %d", findIndexOfSmallest(testArray)); }}

Page 46: prosedyreorientert programmering

48

Programklasse i Eclipse:Finn minste element i en tabell

Page 47: prosedyreorientert programmering

49

Example1

1. Ved programstart– Arkene for Example1og Java sine standard-klasser opprettes (levetid)

2. Initialisering av klasser– melding-attributtet initialiseres til ønsket verdi (levetid)– main-navnet refererer til metode-koden (levetid)

3. main-metoden– args-variabelen knyttes til program-argumentene

(levetid)– System.out til System-klassen sitt out-attributt (synlighet)– testArray refererer til Example1-klassen sitt testArray-attributt (synlighet)

HelloWorld- int[] testArray = - void main()

public class Example1 {

static int findIndexOfSmallest(int array[]) { int indexOfSmallest = 0, currentIndex = 1; … }

static int[] testArray = {1, 2, 3, 4, 3, 6, 8, -1, 0};

public static void main(String[] args) { System.out.printf("Index of smallest is %d", findIndexOfSmallest(testArray)); }}

Example1.main- String[] args =

System- PrintStream out =- void arraycopy(...)

2

3

1

1

3

2

2

Page 48: prosedyreorientert programmering

50

Example1

1. ...2. ...3. main-metoden

– args-variabelen knyttes til program-argumentene (levetid)

– System.out til System-klassen sitt out-attributt (synlighet)– testArray refererer til Example1-klassen sitt testArray-attributt (synlighet)

4. findIndexOfSmallest– array-variabelen er argumentet som overføres i kallet (levetid)– indexOfSmallest og currentIndex er lokale variabler (levetid)– ingen av main sine variabler er synlige (synlighet)

HelloWorld- int[] testArray = - void main()

public class Example1 {

static int findIndexOfSmallest(int array[]) { int indexOfSmallest = 0, currentIndex = 1; … }

static int[] testArray = {1, 2, 3, 4, 3, 6, 8, -1, 0};

public static void main(String[] args) { System.out.printf("Index of smallest is %d", findIndexOfSmallest(testArray)); }}

Example1.main- String[] args =

System- PrintStream out =- void arraycopy(...)

2

3

1

1

3

2

2

Example1.findIndexOfSmallest- int[] array =- indexOfSmallest =- currentIndex =

4

4

Page 49: prosedyreorientert programmering

51

”Hallo” i JSP og Java• JSP – Hallo.jsp<%!void skrivMelding(String s) {

out.println(s);}%><%String melding = ”Hallo!”;skrivMelding(melding);%>

• Java – Hallo.javapublic class Hallo { static void skrivMelding(String s) { System.out.println(s); } public static void main(String args[]) { String melding = ”Hello world!”; skrivMelding(melding); }}

• Kompilere til Hallo.class: javac Hallo.java• Kjøre som selvstendig program: java Hallo

Page 50: prosedyreorientert programmering

52

Oppgave

• Skriv et program som vha. ei for-løkke sørger for at følgende tabell:int[ ] tabell = { 3, 6, 72, 4 };

får innholdet { 85, 82, 76, 4},ved at en celleverdi settes lik cellen selv + summen av cellene til høyre

Page 51: prosedyreorientert programmering

53

public class EtProgram {

public static void main(String[] args) {int[] tabell = {3, 6, 72, 4};int sum = 0;// summere baklengsfor (int i = tabell.length - 1; i >= 0; i--) {

sum = sum + tabell[i];tabell[i] = sum;

}// skrive ut forlengsfor (int i = 0; i < tabell.length; i++) {

System.out.println("Verdi " + i + " er " + tabell[i]);

}}

}