Informatica Actief
advertisement
Informatica Actief
Knip en plakwerk van Casper Bezemer
moodle.informatica-actief.nl
ii
Inhoudsopgave
1 B3 - JavaLogo
1.1 Java, applets en JavaLogo . . . . . . . . . . . . .
1.1.1 Java, applets . . . . . . . . . . . . . . . . .
1.1.2 Wat is JavaLogo? . . . . . . . . . . . . . .
1.2 Werken met JCreator . . . . . . . . . . . . . . . .
1.2.1 Inleiding JDK en JCreator . . . . . . . . . .
1.2.2 Installatie JDK en documentatie . . . . . .
1.2.3 Installatie JCreator . . . . . . . . . . . . .
1.2.4 Installatie JavaLogo in JCreator . . . . . .
1.2.5 Een eerste programma in JCreator . . . .
1.3 Tekenen in Java . . . . . . . . . . . . . . . . . . .
1.3.1 Tekenopdrachten in een Java programma
1.3.2 Meer kleuren gebruiken . . . . . . . . . . .
1.3.3 Fouten zoeken in een programma . . . . .
1.3.4 Een JavaLogo-applet op een website . . .
1.4 Variabelen en typen in Java . . . . . . . . . . . . .
1.4.1 Variabelen gebruiken in Java . . . . . . . .
1.4.2 Typen . . . . . . . . . . . . . . . . . . . . .
1.4.3 Schrijfopdracht en Font-objecten . . . . .
1.5 Methoden maken voor deeltaken . . . . . . . . .
1.5.1 Nieuwe methoden voor deeltaken . . . . .
1.5.2 Parameters van een methode . . . . . . .
1.6 Herhalingsopdrachten en commentaar . . . . . .
1.6.1 Herhalingsopdrachten maken in Java . . .
1.6.2 Commentaar in een programma . . . . . .
1.7 Invoervariabelen . . . . . . . . . . . . . . . . . . .
1.7.1 Gebeurtenisgestuurde interactie . . . . . .
1.7.2 Invoervariabelen gebruiken . . . . . . . . .
1.7.3 Meer invoervariabelen en keuze . . . . . .
iii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
3
5
5
7
8
8
9
10
10
11
13
16
17
17
19
21
23
23
24
27
27
29
30
30
31
34
iv
INHOUDSOPGAVE
Hoofdstuk 1
B3 - JavaLogo
1.1 Java, applets en JavaLogo
1.1.1 Java, applets
Java
De taal Java die wij in deze cursus gaan gebruiken is een vrij nieuwe taal, ontstaan in ongeveer 1995. Java is een zogenaamde objectgeoriënteerde programmeertaal. Objectgeoriënteerde talen zijn de resultaten van nieuwe ontwikkelingen op het gebied van programmeertalen. Heel kort geformuleerd kun
je zeggen dat met objectgeoriënteerde programmeren het beter mogelijk is om
structuur aan te brengen in programma’s. Iets wat bij veel complexe programma’s
van tegenwoordig waaraan door veel programmeurs tegelijk wordt gewerkt steeds
belangrijker wordt. Andere objectgeoriënteerde talen zijn bijvoorbeeld C++ en
Delphi.
De compiler van Java werkt iets anders dan die van andere talen. De programmacode wordt niet meteen omgezet in machinecode, maar in een zogenaamde bytecode. Een code die bij uitvoering met nog een extra (kleine) vertaalstap moet worden omgezet in machinecode. Een voordeel is dat de bytecode voor alle soorten processoren hetzelfde is. Dit is vooral handig voor programma’s die via internet verspreid worden, zoals applets, programmaatjes die
in een webpagina worden uitgevoerd. Zo’n webpagina kan dan op verschillende
soorten computers bekeken worden.
Applets
In deze cursus zullen we applets gaan maken. Dat zijn (vaak kleine) programma’s
in Java die we binnen een webpagina kunnen uitvoeren. De browser waarmee
we een dergelijke webpagina bekijken download zo´n programma en voert het
uit. Hiervoor is wel een zogenaamde Java Runtime Environment nodig op de
computer van de gebruiker (”Java moet geïnstalleerd zijn”). Flash-animaties
1
2
HOOFDSTUK 1. B3 - JAVALOGO
werken volgens een soortgelijk systeem (in dat geval moet er een Flashplayer
geïnstalleerd zijn.
De HTML-code in figuur 1.1.1 is van een webpagina met een applet.
<HTML>
<HEAD>
<TITLE>A Clock</TITLE>
</HEAD>
<BODY>
<h1>A Clock</h1>
<hr>
<applet code="Clock.class"
width=170
height=150>
</applet>
</BODY>
</HTML>
Figuur 1.1: Deze HTML-pagina laadt een applet genaamd Clock.class in de
webbrowser.
Bekijken we deze pagina in een webbrowser, dan zien we onderstaand scherm
met een lopende klok die bovendien de juiste tijd aangeeft.
Figuur 1.2: Zo ziet de Clock applet eruit op de webpagina.
1.1. JAVA, APPLETS EN JAVALOGO
3
In de code zie je een zogenaamde applet-tag met een verwijzing naar een
applet. De tag lijkt op de tags die je gebruikt om afbeeldingen op een webpagina
weer te geven.
<applet code="Clock.class"
width=170
height=150>
</applet>
Figuur 1.3: De code hierboven laadt de applet in onze HTML pagina
Er zijn drie elementen. Twee daarvan (width en height) geven de afmetingen
van het applet. Het element ”code”bevat de verwijzing naar een class-bestand
met de bytecode van het applet. Dit class-bestand moet dus beschikbaar zijn
naast de html-file, in dit geval in dezelfde map.
In het vervolg van deze cursus gaat het om het zelf maken van zo’n classbestand. Deze bytecode is het eindprodukt van ons programmeerwerk.
1.1.2 Wat is JavaLogo?
De applets die we maken in deze cursus zijn gebaseerd op de tekenalgoritmen die we in cursus B3H07 hebben bestudeerd en ontworpen, maar we gaan
verder dan het maken van tekeningen alleen. We zullen ook allerlei animaties
en interacties mogelijk maken. In een verdiepend onderwerp gaan we bovendien 3D-figuren maken. Voorbeelden van dergelijk applets kun je bekijken op
de JavaLogo-site.
Figuur 1.4: Enkele voorbeelden van wat je in JavaLogo kan doen.
Wat is nu het verschil tussen JavaLogo en Java, en waarom heet deze cursus ’programmeren in JavaLogo’ en niet ’programmeren in Java’ ? We zouden
gebruik kunnen maken van de tekenopdrachten die standaard in Java aanwezig
zijn, maar deze opdrachten zijn voor beginners niet zo eenvoudig te begrijpen.
4
HOOFDSTUK 1. B3 - JAVALOGO
Bovendien is er voor de wat ingewikkeldere tekeningen veel lastig rekenwerk
nodig. Daarom gaan we werken met een extra set tekenopdrachten die we aan
Java hebben toegevoegd. Deze tekenopdrachten zijn afgekeken van de programmeertaal Logo.
Logo
Logo is een educatieve programmeertaal, eind jaren zestig bedacht door Seymour Papert. De bedoeling was een simpele programmeertaal te maken die
speciaal geschikt was voor kinderen. Logo bestond uit een grafisch scherm
waarover je de ”turtle”(een cursor in de vorm van een schildpad) heen en weer
kon laten lopen. Er zijn verschillende vertalingen en varianten van Logo ontstaan in de hele wereld. Vandaag is in België en Nederland en zelfs Engeland
een variant nog heel populair: Superlogo. Die is lang niet meer hetzelfde als de
oorspronkelijke taal, en er zijn veel meer functies dan de oorspronkelijke taal.
Kinderen en volwassenen kunnen er echt uitgebreide programma’s mee maken.
Er bestaan tot op de dag van vandaag ook nog andere varianten maar die zijn
minder populair. Maar ondanks alles hebben alle varianten zeker één ding gemeen met het oorspronkelijke Logo: de turtle.Hieronder zie je een afbeelding
gemaakt in Logo. Klik op hier voor extra informatie en de Logo-code.
Omdat we bij JavaLogo de Logo-tekenopdrachten aan Java hebben toegevoegd programmeren we echt in de taal Java, alleen beschikken we nu over
opdrachten waarmee we makkelijker kunnen tekenen. Als je de cursus B3H07
hebt doorgewerkt, dan heb je al ervaring met deze opdrachten.
Bij een objectgeorienteerde taal als Java is het overigens heel gebruikelijk
om de taal uit te breiden met extra opdrachten. De opdrachten worden dan als
extra klassen aan de taal toegevoegd. Later komen we daar nog op terug.
1.2. WERKEN MET JCREATOR
5
1.2 Werken met JCreator
1.2.1 Inleiding JDK en JCreator
Java Development Kit (JDK)
De gratis verkrijgbare Java Development Kit van Sun, de makers van Java, is
het meest basale gereedschap om Javaprogramma´s te maken. De JDK bevat
een compiler, een appletviewer en nog enkele hulpprogramma’s die bestuurd
kunnen worden vanaf de DOS-prompt. Daarnaast is er wel nog een tekst-editor
nodig om de code te kunnen typen en opslaan. Het programma Kladblok van
de Bureau accessoires van Windows, is hiervoor geschikt.
6
HOOFDSTUK 1. B3 - JAVALOGO
Ontwikkelomgeving: JCreator
Makkelijker dan het kale JDK, is een zogenaamde IDE (Integrated Development
Environment), in het Nederlands: een geïntegreerde ontwikkelomgeving. Zo’n
programma biedt alles wat we nodig hebben in één gebruiksvriendelijke omgeving. We kunnen de programma’s schrijven, compileren en testen. Bovendien
heeft het faciliteiten om onze projecten met alle bijbehorende files te ordenen
en te organiseren. In deze Cursus werken we met JCreator van het bedrijf Xinox. De versie die we zullen gebruiken is gratis verkrijgbaar.We zullen dus in
het begin wat aandacht moeten besteden aan de werking en de installatie van
JCreator, zodat we daarna de aandacht vooral kunnen richten op het eigenlijke
programmeren.
1.2. WERKEN MET JCREATOR
7
1.2.2 Installatie JDK en documentatie
De Java Development Kit (JDK) van Sun bevat alle basale tools die nodig zijn
voor het maken van Javaprogramma’s. De JDK is gratis te downloaden vanaf de
site van Sun (Sun downloadsite voor de JDK). In deze handleiding gaan we uit
van de versie JDK 6 update 3. Je kunt deze versie ook rechtstreeks binnenhalen
via de link: JDK 6 (Java Development Kit).
•Download het bestand en start de installatieprocedure.
Accepteer de license agreement en ga door tot je komt bij onderstaand
scherm.
Eventueel kun je een andere map kiezen waarin de JDK geïnstalleerd wordt.
Standaard gebeurt dit in de map C:\Program Files\Java\jdk1.6.0_03. Ook
kun je ervoor kiezen om niet alle onderdelen te installeren. In elk geval heb je
de Development Tools nodig.
•Kies Next.
8
HOOFDSTUK 1. B3 - JAVALOGO
•Kies Finish
De JDK is nu geïnstalleerd .
Vervolgens installeren we de Java documentatie. Deze kan weer gedownload worden via de site van Sun, of rechtstreeks via de link: JDK 6 Documentatie. Het betreft een zipbestand dat moet worden uitgepakt in de map van de
JDK.
1.2.3 Installatie JCreator
Zie de website van Informatica Actief. Deze pagina krijg ik niet mooi in dit boek,
omdat ’ie meer plaatjes is dan tekst.
1.2.4 Installatie JavaLogo in JCreator
Zie de website van Informatica Actief.
1.2. WERKEN MET JCREATOR
1.2.5 Een eerste programma in JCreator
Zie de website van Informatica Actief.
9
10
HOOFDSTUK 1. B3 - JAVALOGO
1.3 Tekenen in Java
1.3.1 Tekenopdrachten in een Java programma
In de cursus B3H07 hebben we een verzameling tekenopdrachten gedefinieerd.
In het applet: “Tekenalgoritmen bouwen” konden we deze opdrachten uitvoeren
en de bijbehorende tekening bekijken. In deze cursus gaan we dezelfde tekenopdrachten omzetten in een Javaprogramma. We zullen zien dat we daarmee
veel extra mogelijkheden krijgen die niet kunnen in het applet waarmee we de
tekenalgoritmen in B3H07 testten.
Je kunt de tekenopdrachten van B3H07 nogmaals bestuderen via de link
B3H07: De tekenopdrachten en het tekenblad.
We bekijken nogmaals het volgende algoritme:
vooruit(100)
rechts(90)
vooruit(100)
links(90)
vooruit(100)
links(60)
vooruit(100)
Het Javaprogramma dat dit tekenalgoritme uitvoert ziet er zo uit:
Programma 1
import logotekenap.*;
public class Applet1 extends TekenApplet
{
public void tekenprogramma()
{
vooruit(100);
rechts(90);
vooruit(100);
links(90);
vooruit(100);
links(60);
vooruit(100);
}
}
We lopen de details van dit programma door.
public class Applet1 Een programma in Java bestaat altijd uit een of meer
zogenaamde klassen (engels: class). Wij zullen ons in de programma’s
die we gaan maken doorgaans beperken tot één klasse. De opdrachten
1.3. TEKENEN IN JAVA
11
moeten dus binnen een klasse staan en de naam van de klasse: Applet1 is
de naam van ons programma. Bovendien moet de naam van het bestand
waar de code in staat ook dezelfde naam hebben, in ons geval is die naam
Applet1.java .
Het woord: public geeft aan dat de klasse van buitenaf kan worden gebruikt.
extends TekenApplet Dit wil zeggen dat je bij het maken van Applet1 in feite
doorbouwt op de applet: TekenApplet. In TekenApplet zijn alle tekenopdrachten gedefinieerd die je in je tekenprogramma kunt gebruiken. Ook
de eerste regel van de code hangt hiermee samen.
import logotekenap.* Om die klasse TekenApplet te kunnen gebruiken, moet
deze voor ons programma toegankelijk worden gemaakt. Dat gebeurt
door de opdracht: import logotekenap.* . logotekenap is een zogenaamd
package (een soort map) waarin TekenApplet te vinden is.
De regel: public class Applet1 extends TekenApplet noemen we de header van de klasse. Alles wat tussen de accolades staat die hierop volgen
(de rest van het programma dus) noemen we die body van de klasse.
public void tekenprogramma() In een objectgeoriënteerde taal als Java moeten alle opdrachten bovendien gebundeld worden in groepjes. Zo’n groepje
heet een methode. De naam van de methode waarin onze opdrachten
staan is: tekenprogramma(). Aan die twee haakjes kun je zien dat je met
een methode te maken hebt. Het woord: void (dat betekent ‘leeg’) wil
zeggen dat de methode iets doet, maar geen uitvoer heeft. Sommige methoden hebben wel uitvoer, dan staat er in plaats van void iets anders.
Hier komen we later op terug. Het woord: public geeft (net als bij class)
aan dat de methode van buitenaf kan worden aangeroepen.
Net als bij een klasse heeft een methode ook een header en een body. De
regel: public void tekenprogramma() is de header, de rij opdrachten tussen
de accolades die daarop volgt is de body.
Wat we verder in de code kunnen zien is dat alle opdrachten afgesloten worden met een puntkomma. Vergeet dit niet, want anders zal de compiler de code
niet accepteren.
Een ander belangrijk punt is het feit dat Java onderscheid maakt tussen
hoofdletters en kleine letters. Dus de naam applet1 is een andere naam dan Applet1. Het is de gewoonte om de naam van een public variabele/methode/klasse
met een hoofdletter te laten beginnen en de naam van private elementen met
een kleine letter.
1.3.2 Meer kleuren gebruiken
Voor het tekenen van van gekleurde lijnen en inkleuren van figuren gebruik je
respectievelijk de opdrachten penAan(kleur) en vulAan(kleur). Je kunt kiezen
12
HOOFDSTUK 1. B3 - JAVALOGO
uit een beperkte lijst met kleuren: rood, groen, blauw, geel, oranje, cyaan, roze,
magenta, grijs, lichtgrijs, wit en zwart. Er is echter een andere mogelijkheid beschikbaar met meer keuzes.
penAan(kleur) Hiermee zet je een denkbeeldige pen aan. Tussen de haakjes
kun je aangeven met welke kleur er getekend moet worden.
penAan(r,g,b) Dezelfde opdracht als hierboven, maar nu je kleur maken door
een rgb-waarde op te geven.
vulAan(kleur) Deze opdracht kun je gebruiken om vlakken in te kleuren. De
kleur kies je door een naam op te geven.
vulAan(r,g,b) Deze opdracht kun je gebruiken om vlakken in te kleuren met
een te kiezen rgb-kleur.
De rgb-kleuren die je in in een van de vorige cursussen al tegenkwam kun je
hier dus gebruiken in de tekenopdrachten. Zowel r, g als b is een getal tussen 0
en 255. Daarmee zijn dus 2563 ≈ 16 miljoen kleuren te maken.
Achtergrondkleur
De achtergrondkleur van het tekenblad was tot nu toe steeds wit, maar ook die
kleur is te veranderen met een opdracht:
achtergrondkleur(kleur) Stelt een gegeven achtergondkleur in door een kleur
naam op te geven
achtergrondkleur(r,g,b) idem, maar nu door rgb-waarden op te geven.
Er is echter een verschil met de andere tekenopdrachten. Deze opdracht
moet niet worden opgenomen in de methode tekenprogramma(), maar in een
aparte methode initialiseer(). Dit is zo omdat het instellen van de achtergrondkleur eigenlijk hoort bij het instellen, oftewel het initialiseren van het tekenblad, terwijl het tekenprogramma zich bezighoudt met het tekenen op het
tekenblad.
Hieronder zie een voorbeeldprogramma waarin een zachtgele ster wordt getekend op een roze achtergrondkleur.
1.3. TEKENEN IN JAVA
13
Programma 2
import logotekenap.*;
public class Applet2 extends TekenApplet
{
public void initialiseer()
{
achtergrondkleur("roze");
}
public void tekenprogramma()
{
vulAan(255,255,200)
vooruit(100);
rechts(144);
vooruit(100);
rechts(144);
vooruit(100);
rechts(144);
vooruit(100);
rechts(144);
vooruit(100);
vulUit();
}
}
1.3.3 Fouten zoeken in een programma
Er bestaat geen programmeur die altijd meteen bij de eerste compilatie een
perfect werkend programma heeft. Dus het opsporen en corrigeren van fouten
is een altijd aanwezig onderdeel van het programmeren. Er zijn verschillende
soorten fouten.
Fouten in de syntax
Allereerst zijn er de zogenaamde syntactische fouten. Fouten die je zou kunnen vergelijken met taalfouten bij het schrijven. Een voorbeeld van een syntaxfout is wanneer je een programma-opdracht niet afsluit met een puntkomma,
of wanneer je de naam van een methode met een hoofdletter schrijft, terwijl je
dat eerder met een kleine letter hebt gedaan. Het kan ook zijn dat je een accolade vergeten bent. Dit soort fouten wordt meestal bij het compileren ontdekt.
Bovendien geeft de compiler aan wat er fout is en in welke regel.
14
HOOFDSTUK 1. B3 - JAVALOGO
Fouten in de semantiek
Semantische fouten zondigen tegen de betekenis van codewoorden. Ook het
gebruik van bouwstenen of procedures waarvan we betekenis, bedoeling of gebruik niet precies kennen, leidt tot semantische fouten. Wanneer je bijvoorbeeld
een tekenopdracht gebruikt buiten de methode tekenprogramma(), dan maak
je een semantische fout. Semantische fouten worden soms wel en soms niet
door de compiler herkend.
Logische fouten
Een ander soort fout is een logische fout. In dat geval heb je soms een werkend
programma, alleen doet het niet wat je wilt. Als je een programma wilt schrijven
dat twee vierkanten moet tekenen, maar het tekent er maar één, dan heb je een
logische fout.
Debuggen
Semantische en logische fouten worden ook wel bugs genoemd. Het opsporen
en verbeteren van dit soort fouten noemen we ’debuggen’ en een ontwikkelomgeving (zoals JDK en JCreator) heeft meestal speciale voorzieningen voor het
debuggen van programma’s.
JavaLogo trace-functie
We zullen nog niet gaan werken met de debugger van JDK en JCreator, maar
met een JavaLogo-optie om fouten in je tekenprogramma op te sporen. Dit is
de zogenaamde ”tracefunctie”. Met deze functie kunnen we de stappen die het
programma uitvoert één voor één bekijken. Om dit te kunnen gebruiken is een
kleine toevoeging aan ons programma nodig. In de methode initialiseer()
geven we de opdracht: maakTraceMogelijk(). Zie het programma hieronder:
1.3. TEKENEN IN JAVA
15
Programma 2a
import logotekenap.*;
public class Applet1 extends TekenApplet
{
public void initialiseer()
{
maakTraceMogelijk();
achtergrondkleur("roze");
}
public void tekenprogramma()
{
vooruit(100);
rechts(90);
vooruit(100);
links(90);
vooruit(100);
links(60);
vooruit(50);
}
}
Onderaan de applet verschijnt nu een knop met trace inschakelen. Wanneer
je hierop drukt, dan kun je het programma stap voor stap doorlopen (zie afbeelding hieronder) met de knoppen: stap, terug en loop. De opdracht die op dat
moment uitgevoerd wordt kun je lezen in het venstertje.
16
HOOFDSTUK 1. B3 - JAVALOGO
Wanneer je kiest voor trace uitschakelen, dan wordt de tekening weer op
de normale manier gemaakt. Met deze tracefunctie heb je een instrument in
handen om fouten in je programmacode te ontdekken, omdat je precies kunt
zien bij welke opdracht de tekening anders verloopt dan je gedacht had. Hiermee heb je een eenvoudige debugger. Wanneer het programma goed werkt,
dan kun je de opdracht maakTraceMogelijk() weer verwijderen.
Tip:
Als je de tracefunctie wilt gebruiken, dan moet je in je applet voldoende ruimte
geven voor de knoppen. Zorg dat je in de html-file een breedte van minstens
450 pixels opgeeft.
<HTML>
<BODY>
<APPLET CODE="Applet1.class" WIDTH="450" HEIGHT="300" >
</APPLET>
</BODY>
</HTML>
1.3.4 Een JavaLogo-applet op een website
Dit is niet onderdeel van het boek omdat Java-applets tegenwoordig zelden
meer uitgevoerd mogen worden in de webbrowser, en daarom dit hoofdstuk
geen toegevoegde waarde meer heeft. Ben je echt benieuwd dan kun je het
lezen op Informatica-Actief.
1.4. VARIABELEN EN TYPEN IN JAVA
17
1.4 Variabelen en typen in Java
1.4.1 Variabelen gebruiken in Java
In cursus B3H07 waarin we tekenalgoritmen maakten, zagen we al het voordeel
van variabelen. Je kunt dit nog eens nalezen via de link ’B3H07: Variabelen
gebruiken in tekenopdrachten’.
Nu gaat het erom hoe we variabelen kunnen gebruiken in Java. We bekijken daarvoor het tekenalgoritme van de rechthoek. Hierin gebruiken we twee
variabelen, één voor de breedte en één voor de hoogte van de rechthoek. Het
voordeel is dat we het algoritme maar op één plaats hoeven te veranderen als
we andere maten willen geven aan de rechthoek.
hoogte = 200
breedte = 400
vulAan("rood")
vooruit(hoogte)
rechts(90)
vooruit(breedte)
rechts(90)
vooruit(hoogte)
rechts(90)
vooruit(breedte)
rechts(90)
vulUit()
Hieronder zie je een Javaprogramma dat dezelfde rechthoek tekent en dezelfde variabelen gebruikt.
Programma3
import logotekenap.*;
public class Rechthoek extends TekenApplet
{
double hoogte;
double breedte;
public void initialiseer()
{
achtergrondkleur("lichtgrijs");
}
public void tekenprogramma()
{
breedte = 400;
hoogte = 200;
18
HOOFDSTUK 1. B3 - JAVALOGO
stap(-breedte/2,-hoogte/2);
vulAan("rood");
vooruit(hoogte);rechts(90);
vooruit(breedte);rechts(90);
vooruit(hoogte);rechts(90);
vooruit(breedte);rechts(90);
vulUit();
}
}
In dit programma komt een aantal nieuwe elementen voor die we zullen toelichten.
Variabele: declaratie
Ten eerste moeten we in ons programma aankondigen dat we met een variabele willen gaan werken. Dit noemen we: een variabele declareren. Dit gebeurt
in ons programma in de eerste twee regels van de body van de class: double
hoogte en double breedte . Bij een declaratie van een variabele moeten we ook
aangeven om wat voor soort variabele het gaat, ofwel het type variabele . In
ons geval willen we dat de variabele een getal is. We hebben dan keuze uit een
geheel getal: een int (komt van het engelse woord voor geheel getal: integer),
of een kommagetal: een double (double komt van het engels voor dubbele precisie.) Omdat we de afspraak hebben dat we tekenopdrachten kommagetallen
meegeven, moeten we voor double kiezen.
Lokale en globale variabelen
Declaraties van variabelen kunnen eigenlijk overal in het programma worden
gedaan. Door de variabelen te declareren binnen de body van de klasse, maar
buiten de body van een methode, kunnen we deze variabelen overal in de klasse
gebruiken. We hadden hoogte en breedte ook kunnen declareren binnen de
methode tekenprogramma() zoals hieronder.
public void tekenprogramma()
{
double breedte;
double hoogte;
breedte = 400;
hoogte = 200;
...
}
1.4. VARIABELEN EN TYPEN IN JAVA
19
Deze variabelen zijn dan alleen te gebruiken binnen deze methode en dat
zou in dit geval eigenlijk ook voldoende zijn geweest. Zulke variabelen die alleen binnen de methode zelf te gebruiken zijn noemen we lokale variabelen.
Zijn de variabelen beschikbaar voor de hele klasse, dan spreken we van globale
variabelen.
Variabele: toekenning
Ten tweede moeten we de variabele een waarde geven. Dit noemen we een
toekenning. In ons programma gebeurt dat in de eerste twee regels van de
methode tekenprogramma(): breedte = 400; en hoogte = 200;. De waardetoekenning aan een variabele moet natuurlijk gebeuren voordat de variabele
gebruikt wordt in een tekenopdracht.
Declaratie en toekenning in één
Het is mogelijk om een variabele tegelijk te declareren en een waarde toe te
kennen. De code wordt korter en soms is dat daarom handig.
public void tekenprogramma()
{
double breedte = 400;
double hoogte = 200;
...
}
Rekenen in Java
Een nieuw element in deze code is dat er gerekend wordt met de variabelen. Dat
zie je in de regel: stap(-breedte/2,-hoogte/2); Deze stapopdracht is bedoeld om
de rechthoek in het midden van het tekenblad te krijgen. Anders zou de linkerbenedenhoek van de rechthoek in het midden van het scherm staan. We moeten de pen eerst een halve rechthoeksbreedte naar links en een halve rechthoekshoogte naar beneden verplaatsen. De uitkomst van de berekeningen breedte/2 en -hoogte/2 geven precies de waarden die we nodig hebben.
In Java kunnen we de bekende operatoren als + (plus), - (min), * (maal), /
(gedeeld door) en ∧ (tot de macht) gebruiken. Bovendien is er klasse Math met
allerlei wiskundige functies beschikbaar. Als je in je programma bijvoorbeeld
de wortel uit 2 wilt gebruiken, dan schrijf je: Math.sqrt(2).
1.4.2 Typen
In het theorieblok 1.4.1, ’Variabelen gebruiken in Java’, kwamen we twee typen
variabelen tegen: double en int. (kommagetallen en gehele getallen). Voor de
tekenopdrachten als vooruit(...) en rechts(...) moet je het type double
20
HOOFDSTUK 1. B3 - JAVALOGO
gebruiken. Dit is niet waar. JavaLogo gebruikt int bij het tekenen, dus de getallen worden sowieso afgerond. Het is wel belangrijk dat je je bewust bent van
dit soort afrondfouten.
double breedte = 400;
double hoek
= 90;
vooruit(zijde);
rechts(hoek);
...
Voor kleuropdrachten met rgb-kleuren, zoals vulAan(..., ..., ...) gebruik je het type int.
int roodWaarde
int groenWaarde
int blauwWaarde
= 255;
= 255;
= 200;
vulAan(roodWaarde, groenWaarde, blauwWaarde);
....
Type: String
We hebben ook tekenopdrachten waarbij de naam van een kleur gebruikt wordt,
bijvoorbeeld: penAan(”rood”), of vulAan(”lichtgrijs”). We hebben hier niet te
maken met een getal, maar een dergelijke kleurnaam kan ook een variabele
zijn. Namen, woorden, of algemener: een rij van letters noemen we in Java een
String. Zo kunnen we een variabele voor een kleurnaam declareren, toekennen
en gebruiken:
String kleur;
....
kleur = "rood";
....
vulAan(kleur);
....
(declaratie van de variabele)
(toekenning van de variabele)
(gebruik van de variabele)
Wat opvalt is dat we een String-waarde tussen aanhalingstekens zetten. Dat
is nodig, want dan ziet de compiler het verschil tussen een String en een naam
van een variabele.
Andere typen
In Java zijn veel verschillende typen variabelen mogelijk. Het is zelfs mogelijk
om je eigen type te maken. Wel is er onderscheid tussen zogenaamde primitieve typen, zoals double en int, en zogenaamde objecttypen die we in Java klassen noemen. Variablen waarvan het type in een klasse beschreven is, noemen
we objecten.
1.4. VARIABELEN EN TYPEN IN JAVA
21
1.4.3 Schrijfopdracht en Font-objecten
In JavaLogo kunnen we in een applet tekeningen maken. Soms is het handig
om ook tekst te kunnen weergeven. Het TekenApplet voorziet daarin met twee
JavaLogo-opdrachten.
schrijf(tekst)
Hiermee zet je een tekst op het scherm op de plaats van de tekenpen op dat
moment. De tekst heeft een standaard lettertype.
schrijf(tekst, font)
Dezelfde opdracht als hierboven, maar nu kun je een lettertype (font) opgeven. De tekst die aan deze opdrachten wordt meegegeven is van het type
String.
Font-objecten
Het font (Engels voor lettertype) dat aan de schrijfopdracht wordt meegegeven
is een zogenaamd object. Het is van een Java-type waarvan de eigenschappen
zijn vastgelegd in de klasse Font. Ook hier komen we in aanraking met objectgeoriënteerd programmeren, maar we gaan niet in op de details. Wel laten we
een stukje programmacode zien waarin het gebruikt wordt.
programma4
import logotekenap.*;
import java.awt.Font;
public class TekstApplet extends TekenApplet
{
Font f;
public void initialiseer()
{
f = new Font("Helvetica", Font.PLAIN,18);
}
public void tekenprogramma()
{
schrijf("Hello world",f);
}
}
Font is een standaard Javaklasse en om die te kunnen gebruiken moeten we
deze importeren in ons programma. Hiervoor is de opdracht:
22
HOOFDSTUK 1. B3 - JAVALOGO
import java.awt.Font
Er moet een variabele van het type Font worden gedeclareerd aan het begin
van de klasse:
Font f
Vervolgens moet er een Font-object gemaakt worden en toegekend aan de
variabele. Dit gebeurt in de methode initialiseer() met de opdracht:
f = new Font("Helvetica", Font.PLAIN,18)
Bij de maken van een Font worden er drie argumenten meegegeven. De
eerste: ”Helveticaïs de fontnaam, de naam van het lettertype. De volgende
fontnamen zijn in Java beschikbaar: Helvetica, TimesRoman, Courier, Dialog,
DialogInput, ZapfDingbats
Als tweede argument hebben we de volgende mogelijkheden:
Font.PLAIN
Font.ITALIC
Font.BOLD
Font.BOLD + Font.ITALIC
Het derde argument geeft de lettergrootte aan uitgedrukt in punten (pt), net
als in tekstverwerkers.
1.5. METHODEN MAKEN VOOR DEELTAKEN
23
1.5 Methoden maken voor deeltaken
1.5.1 Nieuwe methoden voor deeltaken
De cursus B3H07 maakten we al algoritmen met deeltaken. Hoe dat in z’n werk
ging kun je nog eens nalezen via de link: B3H07: Deeltaken in algoritmen. We
maakten het volgende figuur middels een algoritme met twee deeltaken:
Wanneer we dit algoritme omzetten naar een Javaprogramma, dan krijgen
we de volgende code:
import logotekenap.*;
public class DrieSter extends TekenApplet
{
public void tekenprogramma()
{
links(15); vierkant();
rechts(30); ruit();
rechts(90); vierkant();
rechts(30); ruit();
rechts(90); vierkant();
rechts(30); ruit();
}
void vierkant()
{
vulAan("groen");
vooruit(120);links(90);
vooruit(120);links(90);
vooruit(120);links(90);
vooruit(120);links(90);
vulUit();
}
24
HOOFDSTUK 1. B3 - JAVALOGO
void ruit()
{
vulAan("rood");
vooruit(120);links(30);
vooruit(120);links(150);
vooruit(120);links(30);
vooruit(120);links(150);
vulUit();
}
}
Methode definitie
We zien dat de code voor het tekenen van een vierkant is ondergebracht in een
nieuwe methode met de header: void vierkant(). Voor de ruit is hetzelfde
gedaan in de methode: void ruit(). De toevoeging public is hier niet nodig,
omdat de methode niet buiten de klasse gebruikt hoeft te worden. De header en
de body van de methode vierkant() noemen we de definitie van de methode
vierkant().
Methode-aanroep
In de methode tekenprogramma() kun je zien dat de code verschillende keren
vierkant() bevat. Hier wordt de methode vierkant() aangeroepen. Wat dan
gebeurt is dat de code die in de methode-definitie van vierkant() staat wordt
uitgevoerd. Daarna gaat de methode tekenprogramma weer verder waar het gebleven was, bij rechts(30) dus. Vervolgens volgt een methode-aanroep ruit()
en wordt de code bij void ruit() uitgevoerd, enzovoort.
Eigenlijk is het dus zo dat het programma begint in tekenprogramma() en
bij een methode-aanroep naar de code van de bijbehorende methode-definitie
springt en na uitvoering weer terug.
Het voordeel van het werken met nieuwe methoden voor deeltaken is ten
eerste dat een deeltaak maar één keer geschreven hoeft te worden, terwijl deze
meerdere keren kan worden uitgevoerd. We hoeven dus minder code te schrijven. Een tweede voordeel is dat het tekenprogramma veel overzichtelijker wordt
omdat er door het opsplitsen in deeltaken meer structuur is aangebracht.
1.5.2 Parameters van een methode
We hebben gezien dat we een methode kunnen definiëren om een bepaalde
taak uit te voeren, zoals het tekenen van een vierkant met een zijde van 120.
Wanneer je vierkanten van verschillende maten wilt tekenen, hoeft er maar één
getal, de lengte van de zijde, te veranderen. Met een kleine verandering kun je
dezelfde methode gebruiken voor het tekenen van vierkanten met verschillende
maten. De methode aanroep ziet er dan zo uit: vierkant(100), of vierkant(50).
1.5. METHODEN MAKEN VOOR DEELTAKEN
25
De eerste aanroep tekent een vierkant met een zijde van 100, de tweede met een
zijde van 50. Het getal dat wordt meegegeven noemen we een parameter. Dit
getal is de invoer voor de methode.
De aangepaste code voor de methode zie je hieronder.
void vierkant(double z)
{
vulAan("groen");
vooruit(z);rechts(90);
vooruit(z);rechts(90);
vooruit(z);rechts(90);
vooruit(z);rechts(90);
vulUit();
}
In de header van de methode-definitie wordt tussen de haakjes een variabele
z gedeclareerd: double z, op de plaats waar de parameter staat in de methodeaanroep. Deze (lokale) variabele wordt vervolgens in de body van de methode
gebruikt als zijde van het vierkant.
Bij een methode-aanroep wordt aan deze variabele z de waarde van de meegegeven parameter toegekend en op deze manier wordt er een vierkant getekend met de juiste zijde.
Eigenlijk is dit niet nieuw, want in feite zijn de opdrachten vooruit(200) en
rechts(30) ook methode-aanroepen met een parameter. Alleen zijn de methodedefinities in dit geval niet door ons gemaakt. (Die bevinden zich in de klasse
TekenApplet waarop onze programma’s voortbouwen)
Hieronder staat een voorbeeld van een programma dat bovenstaande tekening van 10 vierkanten tekent in 10 verschillende maten.
26
HOOFDSTUK 1. B3 - JAVALOGO
import logotekenap.*;
public class Waaier extends TekenApplet
{
public void tekenprogramma()
{
vierkant(200);rechts(20);
vierkant(180);rechts(20);
vierkant(160);rechts(20);
vierkant(140);rechts(20);
vierkant(120);rechts(20);
vierkant(100);rechts(20);
vierkant(80);rechts(20);
vierkant(60);rechts(20);
vierkant(40);rechts(20);
vierkant(20);rechts(20);
}
void vierkant(double z)
{
vulAan("groen");
vooruit(z);rechts(90);
vooruit(z);rechts(90);
vooruit(z);rechts(90);
vooruit(z);rechts(90);
vulUit();
}
}
We kunnen nu met de nieuwe methode een vierkant tekenen met een willekeurige zijde, maar ze zijn wel allemaal groen. We kunnen ervoor zorgen dat ook
de kleur als parameter wordt meegeven, bijvoorbeeld vierkant(120, "rood"),
door binnen de methodedefinitie voor nog een variabele te zorgen:
void vierkant(double z, String kleur)
{
vulAan(kleur);
vooruit(z);rechts(90);
vooruit(z);rechts(90);
vooruit(z);rechts(90);
vooruit(z);rechts(90);
vulUit();
}
Een kleur wordt voorgesteld door een String, en niet door een getal. Het type
variabele is dus geen double, maar een String (zie 1.4.2 Variabelen: typen).
1.6. HERHALINGSOPDRACHTEN EN COMMENTAAR
27
1.6 Herhalingsopdrachten en commentaar
1.6.1 Herhalingsopdrachten maken in Java
In de cursus H07 leerden we de herhalingsopdracht te gebruiken in onze algoritmen. Je kunt dan nogmaal teruglezen via de link ‘B3H07: Herhalingen gebruiken’.
In Java ziet een herhaling er als volgt uit:
for(int i=0 ; i<4 ; i++)
{
vooruit(100);
rechts(90);
}9
Toelichting op de code: Er wordt een geheel getal (engels: integer) met
naam i gemaakt en dat krijgt als waarde 0: int i = 0. Dit is de teller. Zolang
i kleiner is dan 4, i<4, worden de opdrachten tussen de accolades uitgevoerd.
Dit is de voorwaarde. De opdracht i++ betekent i=i+1, oftewel: i wordt één groter gemaakt. Dit is de eindstap. Zodra de voorwaarde niet meer wordt voldaan,
oftewel i is niet meer kleiner dan 4, stopt de herhaling.
Het is aardig om eens te kijken hoe het programma “Waaier” dat we eerder
maakten eruit kan zien wanneer je gebruik maakt van herhalingen. De code zie
je hieronder:
import logotekenap.*;
public class Waaier extends TekenApplet
{
double zijde;
28
HOOFDSTUK 1. B3 - JAVALOGO
public void tekenprogramma()
{
zijde = 200;
for(int i=0 ; i<10 ; i++)
{
vierkant(zijde);
rechts(20);
zijde = zijde-20;
}
}
void vierkant(double z)
{
vulAan("groen");
for(int i=0 ; i<4 ; i++)
{
vooruit(z);
rechts(90);
}
vulUit();
}
}
In de herhalingslus in de methode tekenprogramma() is de regel zijde =
zijde-20 opgenomen. Hierdoor wordt de variabele zijde na elke herhalingsstap 20 kleiner, waardoor de getekende vierkanten steeds kleiner worden.
Een andere oude bekende is het algoritme voor de krans van vierkanten.
Hieronder het algoritme, compleet met deeltaken uitgevoerd in Java-code.
import logotekenap.*;
public class Krans extends TekenApplet
{
double zijde, afstand;
public void tekenprogramma()
{
zijde = 50; afstand = 100;
penUit();stap(-50,-150);penAan();
rechts(90);
for(int i=0 ; i<9 ; i++)
{
rozet(zijde);
vooruit(afstand);
links(40);
}
}
1.6. HERHALINGSOPDRACHTEN EN COMMENTAAR
29
void rozet(double z)
{
for(int i=0 ; i<45 ; i++)
{
vierkant(z);
rechts(8);
}
}
void vierkant(double z)
{
for(int i=0 ; i<4 ; i++)
{
vooruit(z);
rechts(90);
}
}
}
1.6.2 Commentaar in een programma
Tot nu toe zijn de programma’s die we gemaakt hebben nog vrij klein, overzichtelijk en goed te begrijpen. Bij complexere programma’s is het vaak gewenst
om tussen de code wat uitleg en commentaar te geven. De compiler moet echter wel weten dat deze extra tekst niet bij de echte code hoort. We kunnen een
commentaarregel invoegen door die te laten beginnen met: //.
Het is ook mogelijk om een heel blok commentaar in te voegen. Dit blok
30
HOOFDSTUK 1. B3 - JAVALOGO
moet dan beginnen met /* en afgesloten worden met */. Een voorbeeld zie je
hieronder.
/*deze methode tekent 9 rozetten die op de punten
van een negenhoek geplaatst zijn*/
public void tekenprogramma()
{
zijde = 50; afstand = 100;
penUit();stap(-50,-150);penAan();
rechts(90);
for(int i=0 ; i<9 ; i++)
{
rozet(zijde);
vooruit(afstand);
links(40);
}
}
// deze methode tekent een rozet van 45 vierkanten
void rozet(double z)
{
for(int i=0 ; i<45 ; i++)
{
vierkant(z);
rechts(8);
}
}
1.7 Invoervariabelen
1.7.1 Gebeurtenisgestuurde interactie
De programma’s die we tot nu toe gemaakt hebben missen een belangrijke eigenschap die de meeste computerprogramma’s wel hebben: ze zijn niet interactief. De gebruiker kan zo’n programma uitvoeren en wachten op het resultaat
(de tekening), maar kan niet communiceren met het programma. De gebruiker
kan geen nieuwe invoer leveren, waarop het programma vervolgens reageert
met weer een nieuwe uitvoer. We gaan nu een aantal nieuwe elementen in onze
programma’s inbouwen, waardoor interactie wel mogelijk wordt.
1.7. INVOERVARIABELEN
31
Gebeurtenisgestuurde programma’s
Wanneer je een willekeurig computerprogramma, bijvoorbeeld een tekstverwerker, start, dan gebeurt er meestal het volgende: het programma laat een scherm
zien en wacht vervolgens op een gebeurtenis; het wacht tot de gebruiker iets
doet. Zo’n gebeurtenis kan bijvoorbeeld zijn: het invullen van een tekstvak, het
klikken op een knop, het openen van een menu of het verslepen van een icoon.
Na zo’n gebeurtenis komt de computer met een reactie, zoals bijvoorbeeld het
openen van een dialoogvenster, het opslaan van een document, of het afsluiten
van het programma.
In het vorige onderwerpen hebben we JavaLogoprogramma’s leren kennen
als een serie opdrachten die achtereenvolgens worden uitgevoerd. Een nieuw
aspect van een programma is dat het reageert op gebeurtenissen.
1.7.2 Invoervariabelen gebruiken
In eerdere programma’s heb je variabelen gebruikt. In het logotekenap-package
is de mogelijkheid ingebouwd om de waarden van variabelen te veranderen,
zonder dat het programma opnieuw hoeft te worden gecompileerd en opgestart. Dit noemen we invoervariabelen.
Wat is zo’n invoervariabele nu voor ding? Wanneer je het programma uitvoert, dan wordt de invoervariabele zichtbaar als een vakje met een getal erin,
waarvan je de waarde kunt veranderen door op pijltjes te klikken of door zelf
een getal in te vullen. Bovendien staat er een label bij met een beschrijving. In
het applet waarvan de afbeelding hieronder staat, zie je aan de rechterkant zo’n
invoervariabele staan.
De code van dit applet zie je hieronder.
import logotekenap.*;
public class Vierkant extends TekenApplet
32
HOOFDSTUK 1. B3 - JAVALOGO
{
1
InvoerVariabele zijdeInv;
double zijde;
public void initialiseer()
{
zijdeInv = new InvoerVariabele("zijde",0,400,100);
maakZichtbaar(zijdeInv);
zijde = 100;
}
2
3
public void tekenprogramma()
{
stap(-zijde/2,-zijde/2);
vierkant(zijde);
}
void vierkant(double z)
{
vulAan("rood");
for(int i=0 ; i<4 ; i++)
{
vooruit(z);
rechts(90);
}
vulUit();
}
4
public void invoerVarActie(InvoerVariabele iv)
{
zijde = zijdeInv.geefWaarde();
tekenOpnieuw();
}
5
6
}
In de code van het programma zien we nogal wat nieuwe zaken:
1. InvoerVariabele zijdeInv; Dit is een declaratie van een variabele, maar
niet van het type double, maar van het type InvoerVariabele. De naam
van deze Invoervariabele is zijdeInv (in principe zou je hier iedere naam
kunnen gebruiken die je maar wilt).
Variabelen kunnen dus eenvoudige getallen zijn (zoals double of int),
maar ook een String (een rij letters zoals bijvoorbeeld ”rood”) en andere
complexe ’dingen’ met allerlei eigenschappen zijn. Zo’n soort variabele
noemen we een object. Een InvoerVariabele is een voorbeeld van een object.
1.7. INVOERVARIABELEN
33
We maken zo weer kennis met een stukje objectgeoriënteerd programmeren.
2. zijdeInv = new InvoerVariabele("zijde",0,400,100); Voordat een object gebruikt kan worden in een programma moet het ’gemaakt’, oftewel ’gecreëerd’ worden. Dat gebeurt in deze regel binnen de methode
initialiseer(). Met new InvoerVariabele(...) wordt er een nieuw
object van het type InvoerVariabele gemaakt. Dit object wordt vervolgens toegekend aan de naam zijdeInv.
Met behulp van de String en de getallen die tussen de haakjes staan,
wordt bovendien een aantal eigenschappen van het object vastgelegd:
• De String “zijde” bepaalt de tekst die op het label komt te staan.
• Het eerste getal is de kleinste waarde die de InvoerVariabele kan aannemen. Het minimum.
• Het tweede getal is de grootste waarde die de InvoerVariabele kan
aannemen. Het maximum.
• Het derde getal is de standaardwaarde van de InvoerVariabele. De
default.
3. maakZichtbaar(zijdeInv); Na de creatie van het object, wordt met behulp
van deze opdracht de InvoerVariabele zichtbaar gemaakt op de applet.
Bovendien komt er een wit paneel aan de rechterkant van het applet waar
ook andere InvoerVariabelen worden neergezet.
4. public void invoerVarActie(InvoerVariabele iv) Wanneer de gebruiker van het programma de InvoerVariabele een andere waarde geeft,
dan moet het programma daarop reageren met een actie. Wat het programma in dat geval moet doen staat beschreven in de methode:
public void invoerVarActie(InvoerVariabele iv)
{
zijde = zijdeInv.geefWaarde();
tekenOpnieuw();
}
Zo’n methode noemen we een event handler omdat deze bepaalt wat er
moet gebeuren bij een gebeurtenis (Engels: event). Wanneer de gebruiker iets verandert aan een InvoerVariabele, dan wordt deze methode
aangeroepen en uitgevoerd.
5. zijde = zijdeInv.geefWaarde(); Hier wordt de huidige waarde van de
InvoerVariabele zijdeInv opgevraagd en toegekend aan de variabele
zijde. De methode geefWaarde() is onderdeel van objecten van het type
InvoerVariabele en moet dus altijd gebruikt worden in combinatie met
zo’n object. Vandaar de uitdrukking zijdeInv.geefWaarde(). Er valt over
dit soort zaken nog veel te vertellen, maar we zullen hier op dit moment
34
HOOFDSTUK 1. B3 - JAVALOGO
niet verder op in gaan. Voor nu is het voldoende om te weten hoe je de
waarde van een InvoerVariabele kunt opvragen.
6. tekenOpnieuw(); Deze opdracht spreekt eigenlijk voor zich: de opdrachten
in de methode tekenprogramma() worden opnieuw uitgevoerd. Het resultaat is dat de tekening van het vierkant opnieuw gemaakt wordt, maar nu
met de nieuwe waarde van de variabele zijde.
1.7.3 Meer invoervariabelen en keuze
We laten nog een ander programma zien waarin twee InvoerVariabelen worden gebruikt. In dit applet kan zowel de breedte als de hoogte van een rechthoek
onafhankelijk van elkaar worden aangepast.
import logotekenap.*;
public class Rechthoek extends TekenApplet
{
InvoerVariabele breedteInv;
InvoerVariabele hoogteInv;
double breedte;
double hoogte;
public void initialiseer()
{
breedteInv = new InvoerVariabele("breedte",0,400,200);
maakZichtbaar(breedteInv);
hoogteInv = new InvoerVariabele("hoogte",0,400,100);
maakZichtbaar(hoogteInv);
breedte = 200;
hoogte = 100;
}
public void tekenprogramma()
{
stap(-breedte/2,-hoogte/2);
vulAan("rood");
vooruit(hoogte); rechts(90);
vooruit(breedte); rechts(90);
vooruit(hoogte); rechts(90);
vooruit(breedte); rechts(90);
vulUit();
}
public void invoerVarActie(InvoerVariabele iv)
{
if(iv==breedteInv)
{
breedte = breedteInv.geefWaarde();
tekenOpnieuw();
}
if(iv==hoogteInv)
1.7. INVOERVARIABELEN
{
35
hoogte = hoogteInv.geefWaarde();
tekenOpnieuw();
}
}
}
Dit programma lijkt erg veel op het vorige programma. Alleen in de body van
de eventhandler public void invoerVarActie(...) staat een keuzeopdracht
die we al eerder zagen in ‘B3H07: Taken met keuzeopdrachten’. Hier zien we
hoe deze opdracht in Java wordt gebruikt:
Er zijn twee soorten keuzeopdrachten. De eerste is:
if(voorwaarde)
{
opdracht1 ;
opdracht2 ;
....
}
Alleen als de voorwaarde klopt, dan worden de opdrachten binnen de body na
if(...) uitgevoerd.
De tweede is een uitbreiding van de eerste:
if(voorwaarde)
{
opdracht1 ;
opdracht2 ;
....
}
else
{
opdracht1a ;
opdracht2a ;
....
}
Er komt bij dat als er niet aan de voorwaarde voldaan is, dat dan de opdrachten
bij else worden uitgevoerd.
Bekijk de volgende regels:
if(iv==breedteInv)
{
breedte = breedteInv.geefWaarde();
tekenOpnieuw();
}
Er staat het volgende: als de InvoerVariabele iv waarbij de gebeurtenis
plaatsvond gelijk is aan de InvoerVariabele breedteInv, dan moet de breedte
worden aangepast en de tekening opnieuw gemaakt.
Op dezelfde manier kun je de andere keuzeopdracht vertalen:
36
HOOFDSTUK 1. B3 - JAVALOGO
if(iv==hoogteInv)
{
hoogte = hoogteInv.geefWaarde();
tekenOpnieuw();
}
Als de InvoerVariabele iv waarbij de gebeurtenis plaatsvond gelijk is aan
de InvoerVariabele hoogteInv, dan moet de hoogte worden aangepast en de
tekening opnieuw gemaakt.
Let ook even op het teken voor “is gelijk aan”. In Java gebruiken we hiervoor
blijkbaar ==. Het gewone gelijkteken, = , wordt gebruikt bij toekenningen en betekent “wordt gelijk aan”. Bijvoorbeeld zijde = 100 betekent eigenlijk: “zijde
krijgt waarde 100”.
