Hoofdstuk 4 Javalogo
4.2 Theorie
4.2.1. Een programma
Het hart van de computer is de processor, ook wel CPU of CVE genoemd.
In hoofdstuk 4 hebben we gezien dat de processor instructies achter elkaar uitvoert.
Die instructies zijn opgeslagen in het RAM-geheugen van de computer.
Zo'n reeks computerinstructies noem je een computerprogramma.
Een algoritme is een getailleerde beschrijving van hoe je een probleem
moet oplossen, stap voor stap.
En als je de stappen zo beschrijft dat een computer ze kan uitvoeren dan is het een programma.
Een processor kent maar een beperkt aantal instructies, dat is de zogenaamde
instructieset.
Elke instructie wordt met een nummer aangegeven, dat is de zogenaamde opcode.
Verder wordt die instructie meestal toegepast op een getal, dat is de zogenaamde
operand.
Die twee (of meer) getallen vormen samen de opdracht.
Zo kunnen de opdrachten m.b.v. getallen worden aangegeven, en als je zó een programma schrijft dan noem
je dat machinetaal.
De eerste programma's voor de eerste computers werden in machinetaal geschreven, daarom wordt dat ook
wel de eerste generatie programmeertaal genoemd.
De eerste computer, de MARK1 uit 1943, werd bijvoorbeeld zo geprogrammeerd.
Maar het is ontzettend moeilijk om een ingewikkeld programma in machinetaal, dus alleen met getallen,
te schrijven. Ook omdat een ingewikkeld programma uit miljoenen machinetaal-instructies bestaat.
Verder werkt zo'n programma misschien wel op de ene computer, maar niet op een andere. Want elke
processor-fabrikant heeft zijn eigen instructieset voor zijn processoren, en ook het besturingssysteem
speelt daarbij een rol.
Omdat het programmeren in machinetaal, met alleen getallen, ontzettend moeilijk is, werd al snel
geprobeerd dat wat te vereenvoudigen.
Daarom werd voor elke instructie een instructie-woord bedacht, zodat je woorden kon gebruiken in plaats
van getallen.
Dat was dus de tweede generatie programmeertaal, en dat
werd assembleertaal genoemd (in het engels: assembler).
En om er voor te zorgen dat je niet zoveel hoefde te typen werd elk instructie-woord afgekort, en die
afkortingen worden mnemonics genoemd.
Als een programma in assembleertaal was geschreven kon het niet direkt door de processor worden uitgevoerd,
elk instructie-woord moest eerst worden vervangen door de bijbehorende machinetaal-code, dus door een getal.
Maar er was een programma gemaakt, dat voor die "vertaling" zorgde, en dat
werd een compiler genoemd.
Ook het programmeren in assembler is ontzettend moeilijk, want er zijn net zoveel assembler-instructies
voor een programma nodig als machinetaal-instructies. En dat zijn er miljoenen voor een ingewikkeld
programma.
Daarom zijn er zogenaamde "hogere programmeertalen" uitgevonden.
Dat zijn programmeertalen, waarbij je opdrachten in "gewone taal" kunt geven (vrijwel altijd in het engels).
Je kunt dan niet elk woord gebruiken, dat je wilt. Er zijn een aantal opdrachtwoorden die je mag gebruiken,
en welke dat zijn hangt van de programmeertaal af.
De computer moet het dan nog wel omzetten in machinetaal, en zo'n vertaalprogramma heet ook voor deze
programmeertalen een compiler.
Het verschil met een compiler voor assembler is, dat nu niet elke opdracht in één
machinetaalinstructie wordt omgezet. Maar voor elke opdracht heb je meerdere machinetaalinstructies nodig,
soms heb je voor de vertaling van één opdracht wel 100 machinetaalinstructies nodig.
Maar de compiler regelt dat allemaal.
Voorbeelden van hogere programmeertalen zijn Pascal, Basic, Fortran, C.
Dat zijn derde generatie programmeertalen.
Je hebt ook nog vierde generatie programmeertalen,
dat zijn bijvoorbeeld Java, Delphi,
Visual Basic, Visual C++.
Die talen zijn object-geöriënteerd, en wat daarmee bedoeld wordt lees
je wel als we met Visual Basic aan de slag gaan.
4.2.2. Java compileren
Java is een vierde generatie programmeertaal, het is object-geöriënteerd.
Java is in 1995 ontstaan. Het is vrij snel heel populair geworden omdat je er programma's mee kunt maken
die je op webpagina's kunt laten zien en laten werken.
Zo'n programma voor een webpagina heet een applet.
Maar dat heeft wel tot gevolg dat het compileren anders gaat dan bij andere programmeertalen.
Als je bijvoorbeeld een Pascal-programma hebt geschreven, en je wilt het compileren, dan moet je een
compiler gebruiken die machinetaalinstructies gebruikt voor jouw processor en besturingssysteem.
Elke processorfamilie, en elk besturingssysteem heeft zijn eigen processor.
Een machinetaal-programma heeft vrijwel altijd de extensie EXE.
Als je een Pascal-programma hebt ingetypt (dat noem je dan de broncode) en je slaat het op onder de
naam TEST, dan krijgt het automatisch de extensie PAS. Dus de broncode wordt opgeslagen onder de naam
TEST.PAS.
Als je het dan compileert wordt het machinetaal programma opgeslagen onder de naam TEST.EXE.
Als je een Java-applet hebt ingetypt, en je slaat het op onder de
naam Test, dan krijgt het automatisch de extensie java.
Dus de broncode wordt opgeslagen onder de naam
Test.java
Als je het dan compileert, dan weet de computer eigenlijk niet voor welke processor-familie het
gecompileerd moet worden, en voor welk besturingssysteem. Want het is de bedoeling dat het programma in
een webpagina wordt getoond, en iedereen kan die webpagina bekijken, met elke computer en met elke
processor-familie en met elk besturingssysteem.
Daarom wordt het niet direkt in machinetaal vertaald, maar er wordt een
tussenstap gebruikt.
Het wordt in een taal vertaald die wel heel dicht bij machinetaal ligt, maar het niet is. Dat wordt
bytecode genoemd. En het programma dat voor die vertaling zorgt is
JDK (dat is de afkorting van
Java Development Kit). Het wordt ook wel SDK (Software Development Kit) genoemd.
De computer moet wel weten waar hij dat programma kan vinden.
Als je het programma JCreator voor de eerste keer gebruikt moet je aangeven in welke map JDK zit.
Dat doe je door in het menu te klikken op Configure, en dan op Options.
Dan krijg je onderstaand venster in beeld.
Klik dan op JDK Profiles, en dan op New. Dan krijg je een venster, waarin je de map met JDK aan kunt geven.
Het bestand met de bytecode, waarin het vertaald wordt,
krijgt de extensie class.
Als de broncode Test.java heet, dan krijgt de bytecode de naam Test.class
Als iemand de webpagina bekijkt, waarin dat java-applet voorkomt, dan gaat de computer van diegene het
class-bestand compileren in machinetaal.
Daarvoor is het programme JVM nodig, dat is de afkorting van Java Virtuele Machine.
Dat is een plugin, die bij je browser hoort. Het wordt ook wel JRE (Java Runtime Environment) genoemd.
Dat programma zorgt er voor dat, zodra die webpagina geladen wordt, het class-bestand eerst in machinetaal
vertaald wordt (daarom wordt het ook wel een JIT-compiler genoemd, van Just In Time).
En daarna kan het pas getoond worden. Daarom duurt het soms ook nogal lang voordat je zo'n webpagina met
een java-applet in beeld hebt, vooral op wat oudere computers.
4.2.3. Een Java-programma
Een Java-programma wordt een klasse genoemd. Een klasse is eigenlijk
niet hetzelfde als een programma, maar voorlopig gaan we daar maar wel even van uit.
Het is de gewoonte in Java om de naam van een klasse met een hoofdletter te laten beginnen.
In programmeertalen kunnen opdrachten in groepjes worden gebundeld. Zo'n groepje heet in de meeste
programmeertalen een procedure, maar
in Java wordt het een methode genoemd.
Je hebt in hoofdstuk 1 bijvoorbeeld gezien dat je een methode vierkant kunt maken.
En dan kun je in het hoofdprogramma de opdracht vierkant() geven, dat heeft dan tot gevolg
dat er een vierkant wordt getekend.
Het is de gewoonte in Java om de naam van een methode met een kleine letter te laten beginnen, maar
sommige van de volgende lettergrepen worden vaak wel met een hoofdletter geschreven.
Bijvoorbeeld de methode maakDriehoek
Het is in Java heel gebruikelijk methoden te gebruiken, die in andere programma's voorkomen.
In JavaLogo gebruiken we bijvoorbeeld de methode vooruit(100), en dat is een methode die in de klasse
TekenApplet is beschreven.
Daarom begint elk JavaLogo-programma met de regel:
import logotekenap.*;
Dat betekent dat alle klassen, die in de map logotekenap staan, worden geïmporteerd.
En dat betekent weer dat alle methoden, die in die klassen zijn gedefinieerd (dus beschreven), in je
eigen programma gebruikt mogen worden.
Na die regel komt de zogenaamde header (nederlands: kop; de titel zeg maar) van het programma.
Als de naam van het programma Test is, dan is die regel als volgt:
public class Test extends TekenApplet
Public class betekent dat de methoden van dit
programma ook door anderen gebruikt kunnen worden. Maar dan
moet het wel geïporteerd worden op de manier zoals logotekenap geïmporteerd wordt.
En extends TekenApplet wil zeggen dat je bij het maken van
het programma voortbouwt op de klasse TekenApplet.
Na de header komen de methoden van de klasse, geplaatst tussen accolades.
Wat er na de header komt, tussen de accolades, wordt de body genoemd.
Dat ziet er dus als volgt uit:
public class Test extends TekenApplet
{
...............
...............
}
4.2.4. Methoden en parameters
Een Java-programma bestaat uit één of meer methoden.
In JavaLogo moet er in ieder geval een methode met de naam tekenprogramma zijn.
En de opdrachten, die in die methode staan, zorgen voor de tekening.
Een methode bestaat, net als een klasse, uit een header en een body. En de opdrachten in de body staan
ook weer tussen accolades.
De belangrijkste methode, die in alle JavaLogo-programma's aanwezig moet zijn, ziet er als volgt
uit:
public void tekenprogramma()
{
...............
...............
}
Als de header van een methode met het woord public begint, dan
betekent dat dat die methode ook in andere programma's gebruikt mag worden.
(de klasse moet dan wel geïmporteerd worden).
Als de header met het woord private begint, dan
mag die methode niet in andere programma's gebruikt worden.
Waarom het woord void in de header staat wordt verderop uitgelegd.
Vaak heb je ook een methode met de naam initialiseer in JavaLogo.
Die wordt altijd als allereerste uitgevoerd, maar daar kunnen
geen tekenopdrachten in staan.
Je kunt in die methode bijvoorbeeld de achtergrondkleur bepalen, en of de
tekenopdracht stap-voor-stap
uitgevoerd kan worden.
public void initialiseer()
{
achtergrondkleur("geel");
maakTraceMogelijk();
}
Verder heb je vaak nog methoden omdat je het tekenen van de totale figuur verdeelt in een aantal
deeltaken.
Bijvoorbeeld een methode vierkant:
public void vierkant()
{
penAan(); vulAan("blauw");
vooruit(100); rechts(90);
vooruit(100); rechts(90);
vooruit(100); rechts(90);
vooruit(100); rechts(90);
vulUit(); penUit();
}
Dan kun je in de methode tekenprogramma de opdracht vierkant();
gebruiken, en dat heeft dan tot gevolg
dat er een vierkant met zijde 100 getekend wordt, dat blauw gekleurd wordt.
Je kunt ook een methode vierkant maken, waarbij de zijde en de kleur variabel zijn:
public void vierkant(int z, String k)
{
penAan(); vulAan(k);
vooruit(z); rechts(90);
vooruit(z); rechts(90);
vooruit(z); rechts(90);
vooruit(z); rechts(90);
vulUit(); penUit();
}
Dan kun je in de methode tekenprogramma de opdracht vierkant(100, "blauw");
gebruiken,
en dat heeft dan tot gevolg
dat er een vierkant met zijde 100 getekend wordt, dat blauw gekleurd wordt.
Maar je kunt bijvoorbeeld ook de opdracht vierkant(70, "rood");
gebruiken,
en dat heeft dan tot gevolg
dat er een vierkant met zijde 70 getekend wordt, dat rood gekleurd wordt.
Je kunt de lengte van de zijde in de methode dus met een letter (of een woord, bijv. zijde) aangeven, dat
wordt een parameter genoemd.
En de kleur kun je in de methode ook met een letter (of een woord, bijv. kleur) aangeven, dat is
dan ook een parameter.
Bij de aanroep van de methode met bijvoorbeeld vierkant(70, "rood");
wordt de parameter z in de methode vervangen door 70, en de parameter k door "blauw".
Je moet in de header van de methode die parameters tussen haakjes, achter de naam van de methode, zetten.
En je moet daarbij aangeven van welk type de parameters zijn, gehele getallen, kommagetallen of woorden of
misschien nog iets anders.
Dat noem je het declareren van de parameters.
Een geheel getal geef je aan met int, dat is de afkorting van
integer, en dat is engels voor een geheel getal.
Een woord geef je aan met String (denk om de hoofdletter), dat
is engels voor ketting (een woord is een ketting van letters).
Tenslotte heb je nog methoden, waarin een berekening wordt gemaakt, en die een uitkomst opleveren.
Je kunt bijvoorbeeld een methode maken, waarin de BMI (Body Mass Index) van iemand wordt berekend.
Zo'n methode zou er als volgt uit kunnen zien:
public float bmi(int lengte, int gewicht)
{
return lengte / (gewicht * gewicht);
}
Je ziet dat de header van deze methode begint met public float.
Wat public betekent weet je al, en float staat voor kommagetal.
Dat betekent dat de uitkomt van deze methode een kommagetal is.
(en die uitkomst wordt altijd de uitkomst van de berekening, die in de
methode achter return staat).
Als een methode geen uitkomst oplevert, dan begint de header van die methode altijd met public void
Het woord void betekent leeg.
Bijna elke methode in JavaLogo is van het type void, omdat er meestal alleen getekend wordt en er geen
berekening wordt gemaakt die een uitkomst voor de methode oplevert.
4.2.5. Variabelen en declaraties
Je kunt in Java-programma's ook variabelen gebruiken.
Dat zijn letters of woorden, die getallen of woorden of andere dingen voorstellen.
Je kunt bijvoorbeeld de variabele zijde gebruiken.
Als je de methode vierkant(int z, String k), zoals hierboven, in je programma hebt ingevoerd, dan kun je
de volgende opdrachten geven in de methode tekenprogramma:
public void tekenprogramma()
{
int zijde;
zijde = 50;
vierkant(zijde, "blauw");
zijde = 100;
vierkant(zijde, "blauw");
}
Dan krijgt de variabele zijde eerst de waarde 50, en dan levert de opdracht vierkant(zijde, "blauw");
een blauw vierkant met zijden van 50 op.
Vervolgens krijgt de variabele zijde de waarde 100, en dan levert de opdracht vierkant(zijde, "blauw");
een blauw vierkant met zijden van 100 op.
Je kunt de waarde van de variabele dus variëren, vandaar de naam variabele.
Als je een variabele gebruikt dan moet je dat wel aan het programma duidelijk maken. En je moet er
dan bij vertellen van welk type de variabele is, een geheel getal, een kommagetal of een woord of
misschien nog iets anders.
Dat noem je het declareren van de variabele.
De eerste opdracht van de methode is:
int zijde;
Dat is dus de declaratie van de variabele.
Er wordt dan een geheugenplaats gereserveerd voor de variabele,
en wel een geheugenplaats waar een geheel getal in past.
Java neemt daar vier bytes voor, en dat heeft tot gevolg dat het grootste getal dat er in past is
231-1, dus 2147483647, en het kleinste getal is 2-31, dus -2147483648
De tweede opdracht van de methode is:
zijde = 50;
Dan krijgt de variabele zijde de waarde 50.
Je kunt het je zo voorstellen:
Bij de eerste opdracht wordt er een etiket geplakt op de geheugenplaats, met het woord zijde er op.
En bij de tweede opdracht wordt er het getal 50 in gezet.
Bij de vierde opdracht wordt er het getal 100 in gezet, dan is het getal 50 dus weg want er
kan maar één getal in (net als in een kilometerteller).
 
Je mag de eerste twee opdrachten ook combineren tot één opdracht:
int zijde = 50;
Er zijn meer typen dan int, voorlopig heb je genoeg aan de volgende datatypen:
| type | soort | aantal bytes | maximum/minimum |
| int | geheel getal | 4 | ±231 |
| long | geheel getal | 8 | ±263 |
| float | kommagetal | 4 | circa ±1038 |
| double | kommagetal | 8 | circa ±10308 |
| String | woord | | |
4.2.6. Herhalingen
Als je iets tien keer wilt herhalen, dan kan dat met behulp van de opdracht:
for (int i=1; i<=10; i++)
{
..............
}
Daarbij is i een variabele. De beginwaarde is 1, dat is het eerste wat tussen de haakjes staat (samen met het type:
i is een geheel getal, dus int)
De eindwaarde van i is 10, dus i is steeds kleiner of gelijk aan 10, dat is het tweede wat tussen de haakjes staat.
En de betekenis van het derde wat tussen de haakjes staat, i++, is dat i steeds één groter wordt.
Dus i neemt de waarde 1, 2, 3 t/m 10 aan. De variabele i wordt daarom ook wel de teller genoemd, hij houdt bij
tot hoever de herhaling gevorderd is.
Wat er precies herhaald wordt moet tussen accolades staan.
Eigenlijk kun je net zo goed de opdracht als volgt schrijven:
for (int i=0; i<=9; i++)
{
..............
}
Dan neemt i de waarden 0, 1, 2 t/m 9 aan, maar dan wordt het ook 10 keer herhaald.
Je mag ook een andere variabelenaam gebruiken, dus bijvoorbeeld:
for (int k=0; k<=9; k++)
{
..............
}
4.2.7. Commentaar
Bij het schrijven van een java-programma worden meestal commentaarregels toegevoegd.
Die dienen alleen als toelichting bij het programma, ze horen eigenlijk niet bij het programma.
Als het programma wordt uitgevoerd worden die overgeslagen, ze dienen alleen om het programma te
verduidelijken.
Ze dienen ook voor de programmeur zelf. Als die een programma gemaakt heeft, en een jaar later wil hij iets
aan het programma wijzigen, dan weet hij soms zelf niet meer hoe het programma in elkaar zit.
De commentaarregels helpen hem dan op weg.
Als een regel begint met // dan wordt het als een commentaarregel opgevat.
Als het commentaar uit meer dan één regel bestaat dan moet de eerste commentaarregel beginnen met /* en de
laatste commentaarregel moet worden afgesloten met */
(of elke commentaarregel moet je laten beginnen met // )
4.2.8. Structuurdiagrammen
Als je een lastig probleem hebt, dan schrijf je de oplossing niet zomaar op in een programma.
Vaak ga je dan de volgorde, waarin de dingen moeten gebeuren, eerst even op in gewone nederlandse woorden.
Er zijn afspraken over gemaakt hoe je het bijvoorbeeld noteert als je iets wilt laten herhalen.
Ook als de volgorde afhangt van een bepaalde voorwaarde.
Als je het op onderstaande manier noteert dan noem je dat een structuurdiagram.
Gewone opdrachten noteer je in een rechthoek:
Herhalingen noteer je op de volgende manier:
Als de opdrachten afhangen van een bepaalde voorwaarde dan noteer je het als volgt:
|