1. Het if-statement in een extra constructor
We willen graag ook giftige bloemetjes kunnen toevoegen. Wat we echter niet willen is 2 classes maken voor dezelfde bloem. Zoals in onderstaande afbeelding is het dus fout.
We moeten toe naar deze situatie waarbij we maar één class gebruiken voor verschillende bloemetjes. Dat is de kracht van java!
We gaan dat bereiken in twee stappen. Eerst zullen we leren wat een if-statement is en daarna, of eigenlijk tegelijkertijd, zullen we dit toepassen in de constructor van de class Flower.
Open de class Flower en type het if-statement in de constructor.
Wat hebben we daar gedaan? Verschillende dingen. Eerst hebben een nieuwe constructor gemaakt met één argument. We noemen dat vanaf nu een parameter. Deze parameter gebruiken we in het if-statement. Het if-statement spreekt min of meer voor zichzelf. Als de parameter poisonous waar is dan wordt de code binnen de accolades uitgevoerd.
De oude constructor hebben we een beetje aangepast.
We hebben nu dus 2 constructors. Eén met de standaardinstellingen waarin het roze bloempje is ingesteld en een constructor met één parameter die instelt dat het bloemetjes blauw worden. Alhoewel deze constructie waarschijnlijk goed zal werken zijn we nog niet helemaal klaar. Belangrijk is dat je robuuste code maakt. Dat is code waarvan je zeker weet dat het altijd werkt. We breiden daarom het if-statement ook nog uit met een else-statement en laten hieronder meteen de gehele class zien, inclusief beschrijving en versie-datum bovenaan in de class.
compileren
Misschien heb je bij het bewaren van code een keer op compileren moeten klikken. Een compiler (letterlijk samensteller of opbouwer) is een computerprogramma binnen java wat mensentaal omzet in machinetaal. We noemen dat ook wel het vertalen van een hogere naar een lagere taal. Zo'n lagere taal noemen we assembleertaal of machinecode.
Vaak gaat het compileren tegenwoordig binnen Greenfoot automatisch. Als het niet automatisch gaat is er vaak sprake van een error.
2. De constructor gebruiken
We zullen nu in de class Level1 de constructor gebruiken door bij de roze bloempjes de standaard constructor (zonder parameters) te gebruiken. Voor de blauwe bloempjes gebruiken we de constructor met de parameter poisonous. Dit doen we als volgt:
Met de code new Flower() maken we dus een roze bloempjes omdat we daarmee de standaard constructor, zonder parameters, gebruiken en met de code new Flower(true) maken we blauwe bloempjes.
3. bloempjes plukken met het if-statement
We hebben nu Roodkapje lopend en we hebben alle attributen van Level1 geplaatst. De volgende stap is dat Roodkapje de bloempjes kan plukken. Hiervoor maken we dankbaar gebruik van het principe van overerving. In de bovenliggende class van LittleRedCap vinden we in de API de volgende methoden:
Method Summary
|
boolean |
atWorldEdge()
Test if we are close to one of the edges of the world. |
boolean |
canSee(java.lang.Class clss)
Return true if we can see an object of class 'clss' right where we are. |
void |
move()
Move forward in the current direction. |
void |
removeObject(java.lang.Class clss)
Try to eat an object of class 'clss'. |
void |
turn(int angle)
Turn 'angle' degrees towards the right (clockwise). |
Hiervan gaan we eerst de methode canSee(java.lang.Class clss) gebruiken. De API geeft duidelijk aan welk argument moet worden gebruikt namelijk de naam van een class.
Eerst maken we de methode pickFlowers()
Vervolgens gebruiken we de methode canSee() in een if-statement om te testen of Roodkapje in de buurt van een bloempje komt met de naam van de class als argument. Dit is Flower.class.
4. Debuggen
Als we Roodkapje nu zouden runnen, gebeurt er nog niet veel. Dat is vrij logisch. Binnen het if-statement wordt er nog niets uitgevoerd. We kunnen wel het statement wel testen door een simpele debug uit te voeren.
Wat is debuggen?
Debuggen is een must als je programmeert. Het is vooral laten zien wát er binnen een aantal regels code gebeurt. Er zijn hiervoor binnen Greenfoot twee mogelijkheden:
- Een snelle debug door middel van een System.out.println().
- De debugger van Greenfoot gebruiken.
We zullen nu beide mogelijkheden laten zien. We willen graag weten of het if-statement werkt als Roodkapje bij een bloempje in de buurt is. Plaats hiervoor de volgende code:
Als we nu de game runnen zien we zodra Roodkapje bij een bloempje komt het volgende scherm:
Dit is een zogenaamde terminal window waarin Java code kan plaatsen. In zo'n terminal window worden meestal ook de foutmeldingen getoond. Je gaat dat vanzelf een keer tegenkomen. In bovenstaande terminal window zien we duidelijk het woordje "check" staan. Dat betekent dat het if-statement werkt omdat de variabele test wordt geprint. Een variabele is een stukje geheugen waar we iets in kunnen stoppen zoals het woordje "check". In de volgende les leren we hier meer over. We hadden het overigens ook zonder variabele kunnen testen door System.out.println("check") te gebruiken. In dat geval staat de String (het stukje tekst) meteen in de println methode.
veelgestelde vraag
Waarom krijg ik het hierboven getoonde scherm niet?
antwoord: Check eerst of de methode wel wordt aangeroepen in de methode act().
5. variabelen
Een variabele is een stukje geheugen wat op verschillende manieren kan worden ingezet. Een variabele heeft een naam zoals test uit de vorige les en een inhoud zoals "check" uit de vorige les. Ook zijn er verschillende soorten variabele zoals een String (een tekst).
Er zijn drie soorten variabelen:
- klassevariabelen
- parameters
- lokale variabelen
klassenvariabelen
Met klassevariabelen heb je eigenlijk al kennis gemaakt. Hieronder een voorbeeld van een klassevariabele:
Je herkent een klassevariabele meestal aan het woordje private. Verder zie je ook het codewoord int staan. Dat betekent dat deze variabele alleen maar een geheel getal mag zijn. Dat noemen we een integer. Dus 0, 1 ,2 etc.. maar niet 0.1 of 0.2. Dat laatste is een float of een double.
Het feit dat we int of bijvoorbeeld float met een kleine letter schrijven komt omdat het een zogenaamd primitief type is. Dat houdt in dat er geen klasse van is maar als het ware ingebakken zit in Java. Hieronder alle primitieve typen:
| Data Type |
Default Value
|
| byte |
0 |
| short |
0 |
| int |
0 |
| long |
0 |
| float |
0.0 |
| double |
0.0d |
| char |
'' |
| boolean |
false |
Een String wordt wel met een hoofdletter geschreven. In feite is het een samenstelling van één of meerdere chars die zijn samengevoegd. We noemen dit een samengestelde type. In Java wordt een samengestelde type gemaakt met behulp van een klasse. In een klasse kun je namelijk verschillende primitieve klassevariabelen stoppen. Hieronder demonstreren we dat met de variabale house waarbij we de coderegel House house = new House()gebruiken.
In de klasse House kunnen we meerdere (primitieve) typen stoppen zoals het type van het huis in de vorm van een String of de afmetingen in de vorm van een int of een double.
parameters
Parameters zijn variabelen die worden gebruikt als argumenten van een methode of van een constructor zoals bijvoorbeeld turn(int angle). In deze methode wordt de variabele angle (draaihoek) als argument gebruikt van het type int. De methode verwacht dus een geheel getal als argument zoals bijvoorbeeld turn(3).
In de klasse House kunnen we zelf ook een parameter maken zodat als we een nieuwe klasse House gaan aanmaken we verplicht zijn om dit mee te geven. Bijvoorbeeld het type huis House house = new House("eengezinswoning").
lokale variabelen
Lokale variabelen zijn variabelen die alleen binnen een methode werken. Beschouw de lokale variabele die we zullen gebruiken in het volgend lesonderdeel:
De variabele test is dus alleen maar "zichtbaar" binnen de methode pickFlowers. Merk overigens op dat de variabele van het type String is. Een String is een class met methoden die standaard in Java meekomt. Een String is een stukje tekst.
Stel dat we een variabele maken binnen het if-statement dan is deze daarbuiten niet zichtbaar. We zullen dit aantonen met een foutmelding:
Dit zijn in een notedop allemaal lastig principes om meteen te snappen. Met veel programmeren ga je het wel leren.
6. Geavanceerd debuggen
Nu we weten hoe we variabelen kunnen gebruiken zijn we ook in staat om geavanceerder te kunnen debuggen met behulp van de ingebouwde Greenfoot debugger.
We hebben de code weer een beetje aangepast (zie afbeelding) en we gaan opnieuw checken of de code werkt. Hiervoor hebben we in de kantlijn geklikt en een zogenaamde breakpoint aangebracht door in de kantlijnt te klikken (rood omlijnd).
Als we nu de game runnen en Roodkapje over een bloempje laten lopen zien we het volgende:
We zien precies wat er gebeurt en waar we zijn. We zien dat de methode pickFlowers actief is en dat de lokale variabele test de waarde "check" heeft gekregen. Als we nu klkken op step gaat het programma één coderegel verder en zal je zien dat de waarde van test wordt veranderd.
Hoe krijgen we de debugger nu weer gestopt? Het beste kun je hiervoor op de resetknop klikken zodat Roodkapje niet meer bij een bloempje is.
Conclusie: de code werkt en kan nu worden uitgebreid.
