Greenfoot – En kort introduktion til Programmering og Objekt-Orientering

Greenfoot er et computer-program, som kan benyttes til at skrive andre computer-programmer, i et

programmeringssprog kaldet Java. Java er et meget populært programmeringssprog, og er et medlem af

den familie af programmeringssprog, man kalder for Objekt-Orienterede programmeringssprog, Andre

medlemmer af denne familie er sprogene C++ og C# - vi skal benytte C# i undervisningen på 1. og

2.semester.

Java og C# minder meget om hinanden, måske på samme måde som dansk og norsk. Med disse sprog kan

man specificere stort set alt omkring hvordan et computer-program skal opføre sig. Omvendt skal man så

også kende en hel del af sproget, før man kan lave programmer som f.eks. viser noget grafisk på skærmen.

Greenfoot gør det muligt at lære nogle grundlæggende ting om programmering og objekt-orientering, på

en måde hvor man ser noget der er visuelt, og endda også selv kan ændre/tilføje kode (instruktioner om

hvordan programmet skal opføre sig, skrevet i sproget Java), som ændrer på programmets opførsel. Derfor

benytter vi Greenfoot som en (ganske kort) introduktion til programmering og objekt-orientering, inden vi

skifter over til et andet værktøj kaldet Visual Studio, som er meget større og meget mere generelt. Vi skal

bruge Visual Studio til at skrive programmer i sproget C#.

Installation af Greenfoot

Før vi går i gang, skal du have installeret Greenfoot, og et såkaldt scenario kaldet Wombats. Dette er

beskrevet separat i noten ”Greenfoot – installation” (se denne). Så altså:

Få installeret Greenfoot

Hent scenariet Wombats

Start Greenfoot

Åbn scenariet Wombats

Nu er du klar til at komme i gang .

I gang med Wombats-scenariet

Det første vi skal få styr på, er de elementer man kan se i Greenfoot-vinduet. Det er delt op i nogle

områder, som har hver sin betydning.

Menu: Her kan man vælge forskellige handlinger, f.eks. at åbne/lukke et scenario, lukke Greenfoot

helt, osv. Det fungerer helt som en menu i andre programmer.

Kontroller: Her kan man sætte forskellige handlinger i gang, som har at gøre med det scenario, vi

arbejder med lige for øjeblikket. Vi vender tilbage til, hvad disse kontroller bruges til.

Verden: Et Greenfoot-scenario er (næsten) altid en eller anden form for model af en ”verden”.

Denne verden kan så se ud på forskellige måder, og opføre sig på forskellige måder, alt efter hvilket

scenario vi arbejder med. Det markerede område er her hvor vi kan se, hvad der foregår i

Wombats-verdenen lige nu (ikke så meget til at starte med…)

Klasser: Dette er et overordnet billede af, hvordan vores model af verdenen ser ud i dette speci-

fikke scenario. Hver kasse repræsenterer et del-element i vores verden. Det kommer vi til at tale en

del mere om, da det har meget at gøre med begrebet objekt-orientering.

Her til at starte med ser det lidt kedeligt ud… Der sker ingenting, og selv hvis vi vover at klikke på knappen

Run, ser der ikke ud til at ske noget (bemærk dog, at knappen skifter til Pause. Klik på den igen, så vender

den tilbage til Run). Lige nu er vores verden øde. Vi skal have sat noget ind i verden, før der sker noget. Vi

kan starte med at sætte en wombat ind i vores verden. Dette gøres på følgende måde:

Højreklik på kassen i Klasser-området med navnet Wombat.

I den lille menu som fremkommer, vælges new Wombat() – den plejer at være øverst i menuen. Nu

ændrer muse-cursoren (som normalt er en hvid pil) sig til et wombat-ikon.

Før cursoren hen over Verden-området (ind i det sandfarvede område opdelt i kvadrater), og klik

på et af kvadraterne. Nu bliver der indsat et wombat-ikon i det valgte kvadrat.

Udfør det ovenstående nogle gange, så du får indsat nogle wombatter i din verden. Nu ser din verden nok

ud nogenlunde som dette:

Prøv nu at klikke på Run-knappen, og se hvad der sker. Klik på knappen igen (den hedder Pause nu), når du

vil sætte din verden på pause igen.

Opgave 1: Prøv at notere dig så mange detaljer som muligt om, hvordan en wombat helt specifikt opfører

sig. Ingen detaljer er for små! Sammenlign dine observationer med din sidemands observationer. Fik

han/hun noget med, som du ikke fik med (eller omvendt)?

Vi har således nu observeret, at en wombat ser ud til at have en eller anden opførsel, d.v.s. den foretager

sig noget bestemt, når den er i en bestemt situation. Med andre ord; dens opførsel er ikke altid den

samme, men afhænger af hvilken tilstand den er i. Med ”tilstand” menes der – lidt mere formelt – en

samling af enkelte ”værdier”, som tilsammen fortæller noget om hver individuel wombat. En ”værdi” kan

f.eks. være den position, som wombatten befinder sig på i verden. Vi har jo set, at en wombat gør noget

forskelligt, alt efter om den er ved kanten af verdenen eller ej. Denne position må derfor være vigtig, når

programmet skal finde ud af, hvad wombatten nu skal gøre.

Lad os prøve at summere vores første tanker om vores observationer:

En verden kan rumme et antal wombats.

Hver wombat er et ”individ”, på den måde at der er forskel på, hvad hver wombat gør på et givent

tidspunkt. Vi kalder det som en wombat foretager sig for dens opførsel.

Der må være nogle ”værdier” der er afgørende for, hvordan den enkelte wombat opfører sig på et

givent tidspunkt. Dette kan f.eks. være wombattens position i verdenen. Vi kalder samlingen af

disse værdier for en tilstand.

Det ser ud til, at alle wombatter opfører sig ens, når de kommer i den samme situation. Med det

mener vi mere specifikt: når en wombat kommer i en specifik tilstand, vil den altid opføre sig på

samme måde. Det kunne tyde på, at de regler som definerer hvordan en wombat opfører sig, er

fælles for alle wombatter.

Det sidste er faktisk en meget vigtig observation. Man kan også udtrykke det ved hjælp af en figur:

Man kan forstille sig, at disse generelle regler har en eller anden logisk struktur, som siger noget i stil med

”hvis denne wombat er ved kanten af verden, og går i en retning der fører den ud af verden, skal den…”,

og så videre.

Opgave 2: Se tilbage på de observationer omkring en wombats opførsel, som du – og dine klassekamme-

rater – gjorde i Opgave 1. Prøv at formulere dem på en så logisk og præcis måde som muligt. En idé kan

være at stille dem op på formen:

Hvis (noget som kan være sandt eller falsk, og som afhænger af den enkelte wombats tilstand) ->

så (en handling, som wombatten skal udføre)

Klasser og objekter

De regler, som vi efterhånden har fået opstillet for, hvordan en wombat skal opføre sig, må jo findes inde i

Wombat-scenariet et sted. Det må også gælde for de værdier, som vi under et kalder for tilstand. Det gør

de også, nærmere bestemt inde i Wombat-klassen. En klasse er et helt centralt begreb i objekt-orienteret

design og programmering, og er det sted, hvor vi definerer både tilstand og opførsel for et eller andet

begreb, som er relevant for os. I Greenfoot-vinduet er der jo et område som vi kaldte for Klasser; dette

område viser, hvilke klasser der er defineret som en del af Wombat-scenariet. Hver kasse i området svarer

til en klasse, som har den titel der er angivet i kassen. Det ser således ud til, at der er fem klasser i Wombat-

scenariet:

Vi har allerede fået en fornemmelse af Wombat-klassen, idet vi har set at vi kan højre-klikke på kassen

kaldet Wombat, og skabe så mange wombats vi har lyst til. Med andre ord kan vi skabe så mange objekter

vi har lyst til, af en given klasse. Begrebet objekt er også et helt centralt begreb i objekt-orienteret design

og programmering (deraf navnet…), og dækker altså over noget konkret (så konkret det nu kan blive i et

computer-program…) vi kan skabe, på baggrund af en klasse-definition.

Så altså: givet et eller andet begreb, som er relevant for vores verden, vil vi gøre følgende:

Tænke os godt om, og finde ud af, hvad der er relevante værdier i forhold til at definere tilstand, og

hvad der er relevante handlinger i forhold til at definere opførsel.

Lave én klasse-definition, som specificerer alle detaljer omkring tilstand og opførsel

Lave et antal objekter, som hver især opfører sig som specificeret i vores klasse-definition

Det er sådan set alt, hvad objekt-orienteret design og programmering går ud på!

Med denne viden kan vi prøve at kigge lidt nærmere på, hvad der er inde i et objekt. Prøv at føre muse-

cursoren hen over et wombat-ikon inde i verdenen (altså ikke Wombat-kassen i Klasser-området!) , og

højreklik på ikonet. Nu skulle der fremkomme en menu som denne:

Det ser nok lidt forvirrende ud, men der er system i sagerne. Vi ignorerer det øverste punkt for nu, og ser

på den store del i midten (fra act til turnLeft). Prøv nu at vælge menupunktet move, og se hvad der sker…

Du så sandsynligvis, at den wombat du klikkede på, bevægede sig et skridt (det kommer dog an på den

position, din wombat står på!). Alle menupunkterne fra act til turnLeft er navne på forskellige handlinger,

som vi kan få et wombat-objekt til at udføre. Alle disse handlinger definerer således en wombats opførsel.

Opgave 3: Prøv at eksperimentere med at vælge nogle af de forskellige handlinger. Prøv at vælge dem på

forskellige wombat-objekter. Nogle af handlingerne – f.eks. canMove – ser ikke ud til at få wombat-

objektet til at gøre noget. I stedet kommer der et vindue op med noget information. Giver noget af den

information nogen mening for dig? Hvad siger din sidemand? Kan du se om de handlinger hvor der sker

noget, har noget tilfælles i forhold til hvordan de står beskrevet i menuen (Hint: se på ordet der står foran

navnet på handlingen). Hvad med de handlinger, hvor der kommer et vindue frem?

Vi kan altså få et wombat-objekt til at udføre forskellige handlinger, men selve handlingen kan være forskel-

lig, alt efter hvilken tilstand det enkelte wombat-objekt er i. Vi kan overordnet set opdele handlingerne i to

grupper:

Handlinger, som får objektet til at ”gøre noget”, f.eks. tage et skridt.

Handlinger, som giver os noget information om objektet, f.eks. dets position i verdenen.

Man kan også lave denne opdeling i forhold til objektets tilstand. Vi har:

Handlinger, som ændrer objektets tilstand

Handlinger, som giver os information om objektets tilstand

Den sidste gruppe af handlinger giver noget information tilbage, som kan have forskellig type. Hvis vi valgte

getLeavesEaten, fik vi en talværdi tilbage (indtil videre altid 0…), mens valg af canMove gav os en værdi,

som altid er enten true (sand) eller false (falsk). Det er faktisk sådan, at ordet der står foran navnet på

handlingen, fortæller noget om typen af information, vi får tilbage. I vores tilfælde forekommer ordene int,

boolean og void.

Disse tre ord angiver en type for en bid information (det vil vi kalde data fra nu af):

int: data som altid er et helt tal, f.eks. 0, 17, 42, -4, osv..

boolean: data som er enten true eller false

void: intet data kommer tilbage

Den sidste type (void) er lidt speciel, og benyttes når man har med en handling at gøre, som ikke giver

noget data tilbage. Det er typisk de handlinger, som får objektet til at gøre noget, hvad du nok også så i

opgave 3.

Vi er således nu kommet et spadestik dybere i forhold til opførsel: det er åbenbart defineret som et antal

navngivne handlinger, som kan få et objekt til at gøre noget og/eller give os noget data om objektet. Så

langt, så godt. Hvordan nu med tilstand? Prøv igen at højreklikke på et wombat-objekt, og vælg nu menu-

punktet Inspect (næstnederst). Nu kommer der et nyt vindue frem:

Det kan også se noget forvirrende ud, men igen er der system i det. Vi ser i første omgang kun på de fem

første linjer, og beder dig om at ignorere ordene private og int indtil videre. Med de briller på, kan det være

at du kan begynde at se en sammenhæng mellem ordet i hver linje, og den talværdi der står i den tilsvaren-

de kasse, f.eks. ordet y og værdien 2. Mon ikke det betyder, at denne wombat står på en position, som har

y-koordinat 2? Og x-koordinat 0? Hvad med rotation? Kan det have noget at gøre med, hvad vej denne

wombat vender?

Opgave 4: Eksperimentér med at benytte Inspect på forskellige wombat-objekter. Prøv at lade et objekt

udføre nogle handlinger, og prøv så at benytte Inspect igen. Fortsæt, indtil du synes du har en god forstå-

else for, hvad de enkelte værdier betyder. Drøft dine observationer med din sidemand.

Nu har vi faktisk meget godt styr på Wombat-klassen. Hvad med Leaf-klassen? Gad vide hvad den kan

benyttes til?

Opgave 5: Tilføj nogle Leaf-objekter til din verden, på samme måde som du tilføjede Wombat-objekter

(Tip: Hvis du holder Shift nede efter at have valgt new Leaf(), kan du sætte flere Leaf-objekter ind, uden at

skulle vælge fra menuen hver gang). Prøv derefter at eksperimentere med, hvordan Wombat-objekter

opfører sig i forhold til Leaf-objekter. Hvad sker der, når et Wombat-objekt ”møder” et Leaf-objekt?

Hvordan ændrer det tilstanden af et Wombat-objekt (Tip: Husk Inspect)

Et kig ind i noget Java-kode…

Efter at have fået en forståelse for, hvordan et Wombat-objekt hænger sammen, skal vi prøve at kaste et

blik ind i det indre af Wombat-klassen, hvilket vil sige ind i den Java-kode, som definerer klassens tilstand

og opførsel. Da det jo ikke forventes at du kan forstå Java-kode, skal du ikke blive for frustreret over ikke at

forstå koden i detaljer. Vi håber blot at du får et indtryk af, hvordan kode kan være struktureret, og hvor-

dan man overordnet set formulerer f.eks. regler for et objekts opførsel.

Det er meget nemt at finde frem til selve Java-koden for en klasse-definition. Dobbelt-klik på kassen Wom-

bat i Klasser-området i Greenfoot. Nu skulle et nyt vindue gerne åbne sig:

Dette vindue rummer i sig selv næsten lige så mange funktioner som selve Greenfoot-vinduet, og vi

kommer ikke i denne introduktion ind på alle funktionerne. Det vigtigste at bemærke er, at det centrale

område i vinduet (der hvor der står import greenfoot.* i toppen) rummer den Java-kode, der definerer

Wombat-klassen. Prøv at scrolle lidt op og ned i vinduet, for at danne dig et indtryk af, hvor meget kode

der skal til for at definere klassen Wombat.

Som sagt vil vi ikke her komme ned i detaljen omkring selve koden. Vi kigger lidt på et par interessante

stykker kode for klassen, og prøver at få en fornemmelse af, hvad der foregår. En ret vigtig stump kode er

denne (NB: de første tre linjer er ikke Java-kode. Det er en såkaldt kommentar, som er noget som den der

har skrevet koden har indsat, for at gøre det nemmere for andre at forstå koden):

/** * Do whatever the wombat likes to do just now. */ public void act() { if (foundLeaf()) { eatLeaf(); } else if (canMove()) { move(); } else { turnLeft(); } }

Sådan en stump kode er ved første øjekast en sær blanding. Nogle ting giver nok en vis mening, såsom

ordene eatLeaf, move og turnLeft. Disse ord er jo netop nogle af de ord, vi kunne få frem ved at højre-

klikke på en wombat. Valgte vi et af disse ord, udførte wombatten en handling. Når vi i koden skriver f.eks.

move(), betyder det faktisk ”udfør handlingen move”. Andre ting ser mere kryptiske ud, såsom symboler

som {, } og ;, ordene if og else, og koden har også en speciel formatering, hvor der står meget lidt på hver

linje. Alle disse elementer har naturligvis en veldefineret betydning. For eksempel betyder de krøllede

parenteser {} (også kaldet tuborg-parenteser), at det som står mellem dem skal betragtes som en form for

enhed. Lad os se nærmere på en lille bid:

if (foundLeaf()) { eatLeaf(); }

Hvordan var det nu med foundLeaf? Det var en handling, som gav os noget data tilbage om Wombat-

objektet. Mere specifikt får vi en værdi tilbage, som er enten true (sandt) eller false (falsk). Navnet antyder

lidt, hvad det drejer sig om: hvis vi udfører foundLeaf(), får vi nok at vide, om denne wombat har fundet et

blad (et Leaf-objekt) eller ej. Dette vil jo netop være enten sandt eller falsk. Kodestumpen her skal derfor

læses som:

hvis (wombatten har fundet et blad), så { Spis bladet; }

Lidt mere generelt skal denne stump kode – som kaldes for en betinget sætning – således læses som:

if (det som står i parentesen er sandt) { Gør det, som står mellem de to Tuborg-parenteser }

Med den viden kan meningen med hele kode-stumpen nok begynde at fremgå. Her er kode-stumpen igen,

med nogle forklarende kommentarer:

public void act() { if (foundLeaf()) // Hvis wombatten har fundet et blad, så { eatLeaf(); // Spis bladet } else if (canMove()) // Ellers (d.v.s. intet blad fundet): Hvis wombatten kan flytte sig, så { move(); // Flyt til en ny position } else // Ellers (d.v.s. intet blad fundet OG kan ikke flytte sig): { turnLeft(); // Drej mod venstre } }

Hele koden-stumpen beskriver således, hvordan en wombat interagerer med sin omverden. En wombat

kan åbenbart gør tre ting i sit liv:

Spise et blad

Flytte sig

Dreje mod venstre

Disse handlinger udføres, hvis bestemte betingelser er opfyldt. På diagram-form er dette en wombats liv:

Det er nok ikke en helt realistisk model af en wombat, men nok til, at vi kan se principperne i definition af

en opførsel. Opførslen er her sat sammen af forskellige handlinger, som afhænger af wombattens tilstand.

Hvis vi endnu en gang kaster et blik på den oprindelige kode-stump, kan vi se at hele denne definition af

opførsel er ”pakket ind” i et endnu mere overordnet niveau:

public void act() { // Gør det, som vi har beskrevet i diagrammet }

Hele koden-stumpen er nemlig en definition af handlingen kaldet act. I Greenfoot er act det højeste niveau

opførsel kan defineres på. Når vi klikker på Run-knappen, vil Greenfoot igen og igen udføre handlingen

defineret i act, for hvert objekt som befinder sig i verden. Bemærk, at dette er noget specielt for Greenfoot.

Det er ikke en integreret del af objekt-orienteret programmering i sig selv. Det gør det dog ret nemt at

komme i gang med at definere opførsel.

Et naturligt spørgsmål vil nu være: Jamen, hvad så med f.eks. eatLeaf? Er det så en del af selve sproget

Java? Svaret er nej! Hvis man scroller lidt mere rundt i koden for Wombat-klassen, vil man finde denne

kode-stump:

public void eatLeaf() { Actor leaf = getOneObjectAtOffset(0, 0, Leaf.class); if (leaf != null) { getWorld().removeObject(leaf); leavesEaten = leavesEaten + 1; } }

Selve koden er ikke så vigtig, men det er altså her, vi finder definitionen af handlingen eatLeaf. Koden for

eatLeaf benytter selv nogle handlinger, men hvis vi prøver at lede efter en definition af f.eks. getOne-

ObjectAtOffset, leder vi forgæves! Denne handling er en integreret del af Greenfoot, men ikke af sproget

Java som sådan. Dette er en meget typisk måde at organisere kode på: vi definerer overordnede handlinger

ved hjælp af mindre handlinger, som igen er defineret ved endnu mindre handlinger, osv.. Til sidst når vi

ned til handlinger, som er så små og specifikke, at de er en integreret del af Greenfoot. Inde i Greenfoot vil

disse handlinger selv være defineret, indtil man når ned til handlinger, der er en integreret del af selve

sproget Java.

Det kan måske lyde meget indviklet at kode er organiseret på denne måde, men det er jo ikke så forskelligt

fra, hvordan almindelig tekst er organiseret. Vi kan skrive en meget kompleks tekst (f.eks. om wombats ),

men teksten består jo af sætninger, som igen består af ord (der er en del af et sprog vi skriver teksten på),

og selv de enkelte ord kan brydes ned i bogstaver, som er den mindste enhed for tekst.

Afrunding

Denne note giver kun en lille smagsprøve på, hvad det vil sige at designe og programmere objekt-orien-

teret. Design og programmering handler i høj grad om at få et overblik over, hvad det egentlig er man vil

modellere i sit program, og hvor mange detaljer vi skal have med. Vi kunne godt have taget mange flere

detaljer om wombats med (vægt, farve, osv.), men de detaljer er ikke relevante i denne specifikke sammen-

hæng. I et andet program kunne de måske være relevante. Når vi har et rimeligt overblik, kan vi prøve at

organisere alt det, vi gerne vil have med. I objekt-orienteret design og programmering vil man som regel

organisere tingene i klasser, sådan at alt som har med et begreb at gøre, er samlet i en tilsvarende klasse.

Ofte vil de forskellige klasser interagere med hinanden, som vi så det for Wombat og Leaf. Endelig må vi

finde ud af, hvordan vi skal udtrykke alt det vi gerne vil have med, i et bestemt programmeringssprog. Alt

dette kan tage fra nogle få minutter til adskillige år .

Hvis du gerne vil arbejde mere med Greenfoot, kan man finde en del materiale online, og specielt ligger der

på www.greenfoot.org adskillige andre scenarier, som man kan downloade og eksperimentere med.

God fornøjelse!