leren programmeren

Leren programmeren

De eerste stappen in het bouwen van applicaties

Leren programmeren 2

©Stichting Praktijkleren. Auteursrechten voorbehouden. Niets uit dit werk mag zonder voorafgaande schriftelijke toestemming worden openbaar gemaakt en/of verveelvoudigd door middel van druk, fotokopie/reprografie, scanning, computersoftware, microfilm, geluidskopie, film- of videokopie, of op welke ander wijze dan ook.

ICT-LP, 120712/131008, Bureauredactie JW-KMx/MK-KM


0 Inhoud 0 Inleiding ........................................................................................................................................... 6

0.1 Dit practicum ................................................................................................................................. 6

0.2 De context van het practicum ....................................................................................................... 6

0.3 De werkomgeving .......................................................................................................................... 7

0.4 Je toekomstig vak als applicatieontwikkelaar ............................................................................... 7

0.5 De opleiding tot applicatieontwikkelaar ....................................................................................... 7

1 Aan de slag met BASIC ................................................................... Fout! Bladwijzer niet gedefinieerd.

1.1 Inleiding .................................................................................. Fout! Bladwijzer niet gedefinieerd.

1.2 Het starten van BASIC .................................................................................................................... 9

1.3 Eerste BASIC-programma ............................................................................................................ 11

1.4 Rekenen met BASIC ..................................................................................................................... 13

1.5 De variabele ................................................................................................................................. 15

1.6 Herhaald uitvoeren: de opdracht GOTO ..................................................................................... 16

1.7 Beslissingen nemen: het IF THEN-statement .............................................................................. 17

1.8 IF THEN ELSE END IF .................................................................................................................... 18

1.9 Flowcharts ................................................................................................................................... 20

1.10 Stringvariabelen ........................................................................................................................ 21

1.11 Een rekening opmaken voor de kegelbaan ............................................................................... 23

1.12 De array ..................................................................................................................................... 26

1.13 De FOR NEXT-statement ............................................................................................................ 26

1.14 Printen van de bon .................................................................................................................... 29

1.15 Maken van een nette uitdraai ................................................................................................... 31

1.16 USING ........................................................................................................................................ 32

1.17 Het maken van en werken met een executable........................................................................ 32

2 Verder met BASIC ............................................................................................................................... 34

2.1 Menugestuurd programma ......................................................................................................... 34

2.2 Nieuwe BASIC-statements ........................................................................................................... 34

2.3 Declaraties ................................................................................................................................... 35

2.4 GOSUB RETURN ........................................................................................................................... 35

2.5 AND (OR en NOT) ........................................................................................................................ 35

2.6 DO LOOP en andere loopstructuren............................................................................................ 35

2.7 SELECT CASE ................................................................................................................................ 36

2.8 STOP ............................................................................................................................................ 37


2.9 DUMP .......................................................................................................................................... 37

2.10 Aanpassingen aan het programma ........................................................................................... 37

2.11 Meerdimensionale arrays.......................................................................................................... 37

2.12 Data opslaan in bestanden ........................................................................................................ 38

2.13 SUB en FUNCTION ..................................................................................................................... 39

3 Aan de slag met Java .......................................................................................................................... 41

3.1 De broncode ................................................................................................................................ 46

3.2 Verder experimenteren ............................................................................................................... 48

3.3 Meer Java .................................................................................................................................... 51

3.4 If then else ................................................................................................................................... 51

3.5 Het switchstatement ................................................................................................................... 53

3.6 De statements “while” en “do while” ......................................................................................... 53

3.7 Data uitvoer (formatteren uitvoer of zoiets) .............................................................................. 55

3.8 Data invoer .................................................................................................................................. 55

3.9 Het keyword ‘new’ ...................................................................................................................... 56

4 Objectgeoriënteerd programmeren ................................................................................................... 58

4.1 Objecten definiëren ..................................................................................................................... 58

4.2 Overerving ................................................................................................................................... 62

4.3 De ArrayList ................................................................................................................................. 64

4.4 Access modifiers: public en private ............................................................................................. 66

4.5 Constructors ................................................................................................................................ 67

4.6 Casting ......................................................................................................................................... 70

4.7 Generics ....................................................................................................................................... 71

4.8 Static ............................................................................................................................................ 72

5 Aan de slag met bonnen in Java ......................................................................................................... 73

5.1 Het bonnenprogramma in OOP ................................................................................................... 73

5.2 Een betere editor......................................................................................................................... 79

5.3 De gebruikersinterface ................................................................................................................ 80

5.4 Samenvatting ............................................................................................................................... 85

6 Aan de slag met SQL ........................................................................................................................... 86

6.1 SQL-filters .................................................................................................................................... 90

6.2 Datum- en tijdfuncties ................................................................................................................. 93

6.3 Aggregatie ................................................................................................................................... 95

6.4 Normalisatie ................................................................................................................................ 96


6.5 Data wijzigen ............................................................................................................................... 99

6.6 INSERT ....................................................................................................................................... 100

6.7 UPDATE ...................................................................................................................................... 100

6.8 DELETE ....................................................................................................................................... 101

7 Aan de slag met HTML ...................................................................................................................... 103

7.1 Verwijzen naar andere pagina’s ................................................................................................ 107

7.2 IMG, het weergeven van afbeeldingen ..................................................................................... 109

7.3 Opmaak ..................................................................................................................................... 110

7.4 Een echte webpagina ................................................................................................................ 112

7.5 Opmaken met stijlen ................................................................................................................. 113

7.6 Samenvatting HTML .................................................................................................................. 116

Bijlage I Voorbereidingen werkstation ................................................................................................ 117

Basic voor hoofdstukken 1 en 2 ...................................................................................................... 117

Java voor hoofdstukken 3, 4 en 5 .................................................................................................... 117

SQL voor hoofdstuk 5 ...................................................................................................................... 117


0 Inleiding

0.1 Dit practicum In dit practicum leer je aan de hand van praktijkvoorbeelden en opdrachten de basisprincipes van programmeren. Dit practicum is gebaseerd op leren door ervaring. Je begint bij de basis en aan het eind ben je in staat een compleet programma met een database te bouwen.

Dit practicum bevat de praktische beginselen van het bouwen van applicaties. Naast deze praktijk moet je ook de nodige theorie leren over het opzetten en onderhouden van software applicaties en databases.

In het eerste hoofdstuk leer je wat een programma of ook wel applicatie is. Hiervoor maken we gebruik van de programmeertaal BASIC. Deze taal gebruiken we om te leren wat programmeren is, zonder te hoeven beginnen met moeilijke onderwerpen als declaraties, functiedefinities enzovoort. Op basis van eenvoudige opdrachten ga je gelijk aan de slag.

Na de introductie tot het programmeren wordt het tijd om in te gaan op meer formele aspecten van programmeren zoals variabelen en programma structuren (branches, loops, functies). Ook dit gebeurt in BASIC.

Daarna gaan we in op object georiënteerd programmeren. Dit is van belang voor het uiteindelijke doel: het maken van interactieve grafische interfaces. De gebruikte taal hier is Java.

Vervolgens komen databases aan bod omdat de meeste applicaties tegenwoordig databases gebruiken. Elke programmeur moet ten minste enige basiskennis van SQL hebben.

Als introductie voor het maken van webapplicaties beginnen we met HTML. We besteden kort aandacht aan de communicatie tussen de browser en een webserver. Daarnaast bespreken we de beginselen van het bouwen van een webpagina en oefenen we daarmee en afsluitend volgt een opdracht om er zelf een te bouwen.

De opbouw van het hele practicum is platform onafhankelijk. Je werkt met verschillende programmeertalen. Je docent kan, als hij dat nodig vindt, ook eenvoudig toevoegingen maken, gebaseerd op andere talen.

0.2 De context van het practicum In dit practicum ga je beginnen als stagiair op de ICT-afdeling van AmeRijck, een vakantiedorp op een fictief eiland (Helderoog) voor de Nederlandse kust. Vanaf de eerste werkdag krijg je allerlei verschillende soorten opdrachten van je stagebegeleider. Van deze stagebegeleider krijg je alle benodigde informatie zodat je gelijk aan de slag kunt. Tijdens dit practicum wordt veel zelfwerkzaamheid van je verwacht op het gebied van het verkennen van mogelijkheden via internet, omdat dit in de praktijk ook nodig zal zijn.

Op de eerste dag al kom je al in aanraking met een aantal eenvoudige problemen waarvoor je een oplossing moet ontwikkelen in BASIC. Daarna volgen steeds weer andere opdrachten waarvoor verschillende programmeeromgevingen worden ingezet.


Zo ga je achtereenvolgens van de volgende talen/technieken gebruikmaken.

• BASIC • SQL • Java • HTML5

0.3 De werkomgeving Om de opdrachten en taken uit te kunnen voeren is er voor dit practicum een virtuele werkplek beschikbaar. Deze virtuele werkplek bestaat uit een computer waarop Windows 7, alle benodigde applicaties en oefen bestanden staan. De werkplek is beschikbaar in Hyper-V, VMware en VirtualBox formaat. Deze virtuele werkplek is te downloaden via de website van Stichting Praktijkleren.

0.4 Je toekomstig vak als applicatieontwikkelaar Het vakgebied van de applicatieontwikkelaar is de afgelopen jaren veel breder geworden. Voorheen was het vakgebied vooral gericht op het ontwikkelen van administratieve systemen voor organisaties. Nu is het vooral gericht op het ontwikkelen van applicaties (apps) voor mobiele apparaten, het ontwikkelen van games en andere grafische toepassingen.

Door deze ontwikkelingen heeft het vak veel meer inhoud gekregen. De applicatieontwikkelaar heeft vandaag de dag kennis nodig van het goed en structureel opbouwen van applicaties en het verwerken en opslaan van data. Daarnaast is kennis nodig hoe de communicatie tussen de programma’s verloopt en hoe de communicatie tussen een programma en de gebruiker werkt.

Niet alleen heeft de technische kant een snelle ontwikkeling door gemaakt, maar ook de wijze waarop dat deze apps tot stand komen. Nu worden applicaties snel ontwikkeld in dynamische teams. ‘Vroeger’ waren het vooral langlopende projecten.

Deze ontwikkelingen hebben er voor gezorgd dat het vak veel meer inhoud heeft gekregen. Er zijn veel dingen bijgekomen en er zijn maar weinig dingen afgevallen. In dit practicum kom je in aanraking met de verschillende competenties die je nodig zult hebben als applicatieontwikkelaar nieuwe stijl.

0.5 De opleiding tot applicatieontwikkelaar De opleiding tot applicatieontwikkelaar bestaat uit de volgende kwalificaties.

1 Ontwerpen van de applicatie, (cross)media-uiting of game 2 Realiseren van de applicatie, (cross)media-uiting of game 3 Implementeren van de applicatie, (cross)media-uiting of game 4 Onderhouden en beheren van de applicatie, (cross)media-uiting of game

Dit practicum focust zich vooral op de eerste twee kwalificaties. Veel plezier met het doorlopen van dit practicum.


1 Aan de slag met BASIC

1.1 Inleiding Je bent stagiaire en wordt door Giedrius Vasilauskas, je stagebegeleider, rondgeleid langs diverse afdelingen van AmeRijck. Giedrius laat je de organisatie van het bedrijf zien aan de hand van een organogram, een soort plattegrond van de verschillende takken van het bedrijf.

Anita van ’t LandHoofd Administratie

Giedrius VasilauskasICT-beheerder

Gert van HellHoofd Algemene Zaken

Gerald FalconCEO

Quinta TopMedewerker beheer ICT

Rob LawsonMedewerker beheer ICT

Kirsten HarmsICT-beheerder

Gerry AckroydNetwerkbeheerder

Mathilde NijssenMedewerker ICT

Sander de VriesMedewerker ICT

Judith DikApplicatieontwikkelaar

Groenvoorziening

Schoonmaakdienst

Linnendienst

Technische dienst

Roy MakaayCoördinator beveiliging

Gianfranco BliksteenManagementassistent

Victoria Emerald Bedrijfsadm. medewerker

Marilyn WilbrinkAdministratief medewerker

Externe diensten

Joop de KoffHoofd P&O

Daniël DekkerManagementassistent

Marjo HuismanBedrijfsadministrateur

Ada KokSalarisadministrateur

Liza LopulalanBoekhoudkundig medewerker

Sandór MarquezBoekhoudkundig medewerker

Julian CaraxBoekhoudkundig medewerker

Luna JanssenBoekhoudkundig medewerker

Ibn BattutaAssistent-accountant

Mohammed DibBedrijfsadministratief medewerker

Michael van GrolBeveiliger

Mecit AttatürkBeveiliger

Gerard SpitArbomedewerker

Jobien StormHr-medewerker

Sjoerd ZaalMedewerkerpersoneel & arbeid

Savannah BloemperkManagementassistent

Mike LatesMedewerker ICT

Samantha SchoonheidDirectiesecretaresse

Mirjam van BuurenInkoper

Han te KoppeleStrategisch Inkoper

Kimberly van de WielTelefoniste/receptioniste

Samaya Govea Telefoniste/receptioniste

Jonathan JohnsonBedrijfsadministratief medewerker

Hugo GarciaManager Pr

Isaac MoskovicJuridisch medewerker

Renate HalsemaMarketingmedewerker

Gina Mol Communicatiemedewerker

Koos KeetmanCommunicatiemedewerker

Hanna HaverkortHoofd Inkoop

HoofdkantoorCentrale afdelingen

30-11-2009

De in blauw weergegeven personen maken deel uit van het managementteam.

Jean BeddingtonChef catering

Mario LanzaChef-kok

divers personeelrestaurants & catering

Herman BuitenhuisMedewerker beheer ICT

Jan BeursBoekhouder

Figuur 1 Het organogram van AmeRijck

Hoewel een aantal afdelingen is geautomatiseerd, is er toch nog veel werk te doen. Het gaat in eerste instantie om kleine klussen, met name om voor AmeRijckmedewerkers het leven wat te veraangenamen. Zo hebben sommige afdelingen wel de beschikking over computers maar die gebruiken ze nauwelijks omdat er geen bruikbare programma’s op draaien.

De kegelbaan bijvoorbeeld heeft helemaal geen systeem waar de klantenreserveringen kunnen worden gemaakt of waar de gebruikte consumpties worden vastgelegd. Alles gaat hier nog met een handrekenmachine en een kladblok.

Giedrius geeft jou de opdracht om te beginnen met het maken van wat eenvoudige programma’s voor de computer zodat medewerkers geen rekenmachine en papier meer hoeven te gebruiken waardoor ze efficiënter en plezieriger kunnen werken. De programmeertaal die je gaat gebruiken, is BASIC. Eerst ga je BASIC installeren op je pc. Een beschrijving hiervan vind je in de bijlage.


Giedrius legt aan je uit wat programmeren nu eigenlijk inhoudt: het is het opdelen van een taak in een aantal kleinere, meer overzichtelijke taken. Dat kun je steeds verder uitbreiden. Een voorbeeld:

een belangrijke taak in AmeRijck is het dagelijkse schoonhouden van de huisjes. Dat is de hoofdtaak. Deze hoofdtaak kan worden verdeeld in de volgende kleinere taken.

1 Kamers schoonmaken 2 Woonkamer schoonmaken 3 Keuken schoonmaken 4 Toilet en douche schoonmaken 5 Enzovoort

Als we nu naar ‘1 Kamers schoonmaken’ kijken, kunnen we een verdere uitsplitsing per kamer maken. Een kamer schoonmaken bestaat uit de volgende activiteiten.

1 Bedden verschonen 2 Stofzuigen 3 Raam zemen 4 Enzovoort

Bedden verschonen kunnen we weer verder verdelen in stappen, dus bijvoorbeeld voor elk bed in de kamer het volgende te doen.

1 Vuile dekbedovertrek verwijderen 2 Schoon dekbedovertrek om het dekbed doen 3 Onderlaken verwijderen 4 Schoon onderlaken op bed leggen 5 Kussensloop verwijderen 6 Schoon kussensloop om kussen doen 7 Bed opmaken

Enzovoort

Het steeds verder uitsplitsen van taken doe je ook bij programmeren. Net zo lang tot je de taken zo hebt uitgesplitst dat je ze kunt vastleggen in programmacode: heel eenvoudige opdrachten, ook wel statements genoemd.

We beginnen met het bekijken van de BASIC-programmeeromgeving. Hiervoor gebruiken we het programma Just BASIC omdat het eenvoudig te leren is en het is gratis. Later kun je eventueel upgraden naar een meer uitgebreide versie: Liberty BASIC. De afkorting BASIC staat voor Beginners All purpose Symbolic Instruction Code.

1.2 Het starten van BASIC Zoek in het startmenu Just BASIC v1.01 en selecteer dat. Je krijgt het volgende te zien.


Het voorste venster genaamd The World of Just BASIC! kun je sluiten.

Vervolgens kun je de menukeuze File – New BASIC Source File kiezen. Je scherm wordt schoongemaakt en in het scherm ga je BASIC code invoeren. Zoals je ziet, kun je voortaan ook Ctrl+N gebruiken (de controlknop samen met de letter N indrukken).


Je scherm moet er daarna als volgt uitzien.

1.3 Eerste BASIC-programma Je eerste BASIC-programma bestaat uit het intikken van een enkele opdracht.

Tik de volgende opdracht in: PRINT “Goedemorgen, welkom bij de cursus leren programmeren!"


Nu geef je het commando om de code uit te voeren. Selecteer het Run-commando of gebruik de toetscombinatie Shift-F5.

Er opent een nieuw venster waarin de zin “Goedemorgen, welkom bij de cursus leren programmeren!” wordt getoond, als volgt.


Dat was het eerste computerprogramma! De computer heeft de door jou ingetikte opdracht in code vertaald en voert het uit in een ander venster. Sluit nu het voorste venster.

De zin PRINT “Goedemorgen, welkom bij de cursus leren programmeren!” noemt men in programmeerjargon een statement. Je kunt statements onder elkaar op de volgende regel herhalen. Ze zullen dan achtereenvolgens worden uitgevoerd, na klikken op het Run commando.

1.4 Rekenen met BASIC Nu gaan we de computer wat rekenwerk laten doen. De basis rekenbewerkingen van de computer zijn optellen (+), aftrekken (-), vermenigvuldigen (*) en delen (/). Dus we laten de computer de btw berekenen over een bedrag van € 12,00. Let op dat het decimaal teken bij BASIC bestaat uit de punt (.) en niet uit de komma. Druk op menu File en kies ‘New BASIC Source File’ en voer de code in.

Als we dit programma uitvoeren met run (in jargon hebben we het dan over executen of runnen), dan krijgen we het volgende resultaat.

Dat klopt inderdaad als we het narekenen.


Opdracht: breid dit programma uit zodat het bedrag inclusief btw wordt berekend.

Vervolgens kunnen we een tabel maken van de btw over alle bedragen van 1 tot 20 euro.

Met het volgende resultaat.


1.5 De variabele We hebben in het vorige hoofdstuk kennisgemaakt met een statement en met het onder elkaar plakken van een rij statements die dan alle door de computer na elkaar worden uitgevoerd. Minstens zo belangrijk is het begrip variabele. Een variabele kun je je voorstellen als een ‘vakje’ in het geheugen van de computer waarin je gegevens kunt opslaan. Bijvoorbeeld een getal. Zo’n variabele geef je een naam en daarom kun je er in je programmacode naar verwijzen. Ook kun je in dat vakje een bepaalde waarde opslaan en de waarde van die variabele gebruiken. Een variabele kan op verschillende manieren een waarde krijgen.

1 In het programma; in programmacode geef je een variabele een waarde met LET =. Bijvoorbeeld LET A = 5 geeft aan de variabele met naam A de waarde 5.

2 Door een berekening; bij een berekening ziet dat er als volgt uit. LET B = 2 * A. B heeft na uitvoeren van dit statement de waarde 2 * 5 = 10 gekregen.

3 Door de gebruiker van het programma een waarde te laten invoeren; een variabele krijgt van een gebruiker een waarde via het INPUT-statement: INPUT A.

Op die manier kun je bijvoorbeeld een programma maken dat de btw berekent over een bedrag dat door de gebruiker is ingevoerd.

Opdracht: tik dit programma in, voer het uit en sla het nu op als BTW.bas.

Opdracht: maak een programma dat de wisselkoers berekent uit vreemde valuta op basis van een door een gebruiker ingegeven bedrag in euro’s, dollar of pond. Sla dit programma op via het file menu zodat je het later weer kunt gebruiken. Noem het Valuta.bas.

Je ziet dat het een verbetering is door in plaats van A of B namen te gebruiken die iets meer betekenis hebben. Op die manier kun je later in je code makkelijk zien wat je met de variabele doet. Zo zou je bijvoorbeeld A de naam ExclusiefBTW kunnen geven en in plaats van B de naam BTWBedrag gebruiken. Let wel op dat in namen van variabelen geen spaties zijn toegestaan. Ook veel speciale tekens als +, -, * en / zijn verboden. BASIC zou dan namelijk in de war kunnen raken of er een naam wordt bedoeld of dat er sprake is van een berekening. Als je bijvoorbeeld de naam BTWBedrag zou schrijven als BTW-Bedrag dan ziet BASIC dat als BTW – Bedrag (BTW min Bedrag).


Opdracht: ga na welke tekens wel en niet in namen van variabelen mogen voorkomen en waarom dar zo is.

Ten slotte is het mogelijk om bij de statements PRINT en INPUT tekst bij te voegen zodat het voor de gebruiker duidelijk wordt wat hij moet invoeren en wat het resultaat betekent. Dat ziet er als volgt uit.

Daarnaast is het ook goed om commentaar in je code op te nemen om aan te geven wat je in een statement doet. Dat doe je met een REM-statement (REMark = opmerking). Alles achter het woord REM is commentaar en wordt niet gezien als programmacode. Dat is voor jezelf later handig zodat je dan nog weet hoe je programma werkt als je iets wilt aanpassen. Ook als je programma door iemand anders in onderhoud wordt genomen, is het belangrijk.

Opdracht: open je programma BTW.bas en verander het op dezelfde manier. Dus door het toevoegen van commentaar, het gebruik van goede namen voor variabelen en het toevoegen van tekst aan INPUT- en PRINT-statements.

1.6 Herhaald uitvoeren: de opdracht GOTO Giedrius ziet je programma en vindt het op zich wel bruikbaar. Hij vindt het echter onhandig dat je het steeds opnieuw moet starten. Hij zou willen dat het programma actief blijft. Je besluit een herhalingsactie in te bouwen. Je gebruikt hiervoor het GOTO-statement. Met dit statement kun je naar een ander statement springen dan het (standaard) volgende statement.

Eerst ga je de regels statements voorzien van regelnummers. Je moet immers aangeven waar je naartoe moet springen.

Je programma ziet er dan als volgt uit.

REM Het basisbedrag wordt ingevoerd. 1 INPUT "Wat is het bedrag exclusief BTW? " ; ExclusiefBTW REM De BTW berekening wordt uitgevoerd....


2 LET BTWBedrag = ExclusiefBTW * 19 / 100 REM En aan de gebruiker getoond 3 PRINT "Het bedrag aan BTW bedraagt dan: " ; BTWBedrag 4 GOTO 1 De uitvoer laat het volgende zien.

Wat is het bedrag exclusief BTW? 100 Het bedrag aan BTW bedraagt dan: 19 Wat is het bedrag exclusief BTW? 200 Het bedrag aan BTW bedraagt dan: 38 Wat is het bedrag exclusief BTW? 300 Het bedrag aan BTW bedraagt dan: 57 Wat is het bedrag exclusief BTW? 400 Het bedrag aan BTW bedraagt dan: 76 Wat is het bedrag exclusief BTW? Toen BASIC werd ontwikkeld, was het verplicht om elk statement een regelnummer te geven. Tegenwoordig is dat niet meer het geval. Je kunt namelijk ook gebruikmaken van symbolische namen voor labels om naartoe te springen. Zo’n labelnaam geef je aan tussen [].

Stel bijvoorbeeld dat we een label [Begin] gebruiken. Dan ziet de code er als volgt uit.

[Begin] REM Het basisbedrag wordt ingevoerd. INPUT "Wat is het bedrag exclusief BTW? " ; ExclusiefBTW REM De BTW berekening wordt uitgevoerd.... LET BTWBedrag = ExclusiefBTW * 19 / 100 REM En aan de gebruiker getoond PRINT "Het bedrag aan BTW bedraagt dan: " ; BTWBedrag GOTO [Begin] END

Opmerking: er is hier ook een END-statement toegevoegd. Bij echte programma’s moet dat aanwezig zijn om het einde van je code aan te geven.

Opdracht: tik dit programma in, test het en sla het op als btw1.bas.

1.7 Beslissingen nemen: het IF THEN-statement In het vorige voorbeeld blijft het programma doordraaien totdat je het venster waarin het draait afsluit. Giedrius vraagt je om iets te verzinnen zodat de gebruiker het programma vanaf de invoerregel kan afsluiten als hij klaar is. Je besluit dat het programma moet worden afgesloten als de gebruiker 0 invoert als bedrag. Er moet dus nadat de gebruiker een bedrag heeft ingevoerd door BASIC worden beslist of het programma doorgaat of stopt. Dat doe je met het IF THEN-statement. Het werkt als volgt.


[Begin] REM Het basisbedrag wordt ingevoerd. INPUT "Wat is het bedrag exclusief BTW? " ; ExclusiefBTW REM Stoppen? IF ExclusiefBTW = 0 THEN STOP REM De BTW berekening wordt uitgevoerd.... LET BTWBedrag = ExclusiefBTW * 19 / 100 REM En aan de gebruiker getoond PRINT "Het bedrag aan BTW bedraagt dan: " ; BTWBedrag GOTO [Begin] END

Het STOP-statement geeft aan dat het programma moet worden beëindigd.

Een andere manier is om naar een label te springen.

[Begin] REM Het basisbedrag wordt ingevoerd. INPUT "Wat is het bedrag exclusief BTW? " ; ExclusiefBTW REM Stoppen? IF ExclusiefBTW = 0 THEN GOTO [Stoppen] REM De BTW berekening wordt uitgevoerd.... LET BTWBedrag = ExclusiefBTW * 19 / 100 REM En aan de gebruiker getoond PRINT "Het bedrag aan BTW bedraagt dan: " ; BTWBedrag GOTO [Begin] [Stoppen] PRINT “Het programma is gestopt.” STOP END

Met het IF THEN-statement neem je zogenaamde logische beslissingen. In ons geval kijken we of de invoer gelijk is aan 0 door middel van: ExclusiefBTW = 0. Je kunt ook kijken of variabelen groter zijn dan een waarde: ExclusiefBTW > 0, kleiner dan een waarde: ExclusiefBTW < 0 of ongelijk aan een waarde: ExclusiefBTW <> 0 (dus groter of kleiner maar niet gelijk). Ten slotte zijn er nog >= (groter of gelijk) en <= (kleiner of gelijk).


1.8 IF THEN ELSE END IF Vaak wordt de IF THEN gebruikt met de ELSE.

[Begin] REM Het basisbedrag wordt ingevoerd. INPUT "Wat is het bedrag exclusief BTW? " ; ExclusiefBTW REM Stoppen? IF ExclusiefBTW <> 0 THEN REM De BTW berekening wordt uitgevoerd.... LET BTWBedrag = ExclusiefBTW * 19 / 100 REM En aan de gebruiker getoond


PRINT "Het bedrag aan BTW bedraagt dan: " ; BTWBedrag GOTO [Begin] ELSE PRINT "Het programma is gestopt." STOP END IF END

De ELSE geeft aan wat moet worden gedaan als de IF niet moet worden uitgevoerd. Op deze manier kun je met minder labels af. Zoals je ziet geeft de END IF aan waar de code voor de IF THEN ELSE ophoudt.

Het IF-statement kent een aantal varianten.

• IF Conditie THEN Actie De actie staat direct achter de THEN. • IF Conditie THEN Actie ELSE AndereActie IF Conditie THEN Actie1 Actie2 END IF Er zijn meer acties. De END IF geeft aan waar de acties die bij de IF horen ophouden.

• IF Conditie THEN Actie1 Actie2 ELSE AndereActie1 AndereActie2 END IF

Het programma begint nu wel een beetje onoverzichtelijk te worden. Het helpt om de verschillende blokken op een logische manier te laten inspringen. Je ziet dan in een oogopslag welke codes bij elkaar horen. Dat is handig als je later de code wilt aanpassen. Bijvoorbeeld zoals in de volgende weergave.

[Begin] REM Het basisbedrag wordt ingevoerd. INPUT "Wat is het bedrag exclusief BTW? " ; ExclusiefBTW REM Stoppen? IF ExclusiefBTW <> 0 THEN

REM De BTW berekening wordt uitgevoerd.... LET BTWBedrag = ExclusiefBTW * 19 / 100 REM En aan de gebruiker getoond PRINT "Het bedrag aan BTW bedraagt dan: " ; BTWBedrag GOTO [Begin]

ELSE PRINT "Het programma is gestopt." STOP


END IF END


1.9 Flowcharts Tot nu toe hebben we een programma gemaakt door al doende wat aanpassingen te maken aan een bestaand programma. Grote en ingewikkelde programma’s kun je niet op die manier maken. Je zou zonder schematisch weergeven van het programmaverloop al gauw het overzicht verliezen en daardoor fouten maken en onderdelen vergeten.

Een ontwerp van een groot programma wordt vaak met flowcharts gemaakt. Met flowcharts kun je op een schematische manier acties vastleggen en hoe die acties met elkaar verbonden zijn. Als we het voorgaande programma met behulp van een flowchart zouden vastleggen, dan hebben we de volgende schemaonderdelen nodig.

Process: Hierin geef je aan wat de computer moet uitvoeren. Bijvoorbeeld een berekening.

IF THEN ELSE: Hierin geef je beslissingen aan.

Manual input: De gebruiker moet hier iets invoeren.

Scherm output:Iets wordt op het computerscherm getoond.

Terminator: Duidt het einde van het programma aan.

Een flowchart van je programma ziet er als volgt uit (let op de richting van de pijlen).


INPUT ExclusiefBTW

ExclusiefBTW <> 0

BTWBedrag = ExclusiefBTW *

19 / 100STOP

PRINT BTWBedrag

WaarNiet waar

Flowcharts kun je heel goed met de hand tekenen. Om ze netjes te maken kun je ze ook met een speciaal tekenprogramma maken zoals MS Visio. Vanaf nu zullen we bij het maken van een programma altijd eerst een flowchart maken. Op de oefenmachine kun je Visio installeren, zodat je daar voortaan mee kunt werken.

Opdracht: maak de bovenstaande flowchart in VISIO. Maak daarna flowcharts voor je eigen programma’s.

1.10 Stringvariabelen We hebben tot nu toe gewerkt met variabelen voor getallen. Soms moet je in een programma ook gewoon met letters kunnen werken, bijvoorbeeld om iemands naam weer te geven. In plaats van letter spreken we meestal over karakters. Dat kunnen hoofdletters of kleine letters zijn of speciale tekens als punt of komma. In feite stelt elke knop op je toetsenbord precies één karakter voor. Een rij van karakters noemen we een string. Strings hebben we al gezien in de statements INPUT en PRINT waar de waarde(tekst) tussen aanhalingstekens (“ ”) stond.

In BASIC geef je aan dat een variabele een string voorstelt door er een $ teken achter te zetten. Zo zijn A$ en Naam$ variabelen van het type string.

Probeer het volgende stukje programma.

INPUT “Wat is je naam?>” ; Naam$ PRINT “Goedemorgen ” ; Naam$ END Dit programma produceert de volgende uitvoer.

Wat is je naam?>Jan Goedemorgen Jan


In de variabele Naam$ wordt dus de naam opgeslagen. Je kunt strings aan elkaar plakken met behulp van een + teken.

INPUT “Wat is je voornaam?>” ; Voornaam$ INPUT “Wat is je achternaam?>” ; Achternaam$ LET Naam$ = Voornaam$ + Achternaam$ PRINT “Goedemorgen ” ; Naam$ END

Uitvoer: Wat is je voornaam?>Jan Wat is je achternaam?>Jansen Goedemorgen JanJansen

We zouden graag een spatie zien tussen voor en achternaam. Daarom maken we nog de volgende aanpassing. INPUT “Wat is je voornaam?>” ; Voornaam$ INPUT “Wat is je achternaam?>” ; Achternaam$ LET Spatie$ = “ ” LET Naam$ = Voornaam$ + Spatie$ + Achternaam$ PRINT “Goedemorgen ” ; Naam$ END Met als resultaat het volgende.

Wat is je voornaam?>Jan Wat is je achternaam?>Jansen Goedemorgen Jan Jansen

In plaats van

LET Spatie$ = “ ” LET Naam$ = Voornaam$ + Spatie$ + Achternaam$

was het volgende ook goed geweest.

LET Naam$ = Voornaam$ + “ ” + Achternaam$

Opdracht: tik dit programma in, test het en sla het op als naam.bas.


1.11 Een rekening opmaken voor de kegelbaan Giedrius vraagt je of het mogelijk is om voor de kegelbaan een programma te maken dat een totaalbedrag berekent voor een klant. Er zijn drie categorieën die op de bon moeten komen.

• Baanhuur • Bar • Restaurant

Giedrius heeft de volgende flowchart in klad gemaakt.

Opdracht: maak deze flowchart netjes. Het bijbehorende programma ziet er als volgt uit. INPUT "Wat is de voornaam van de klant?>" ; Voornaam$ INPUT "Wat is de achternaam van de klant?>" ; Achternaam$ LET BarBedrag = 0 [BarLabel]

INPUT "Consumptie invoeren:>" ; ConsumptieBedrag IF ConsumptieBedrag <> 0 THEN LET BarBedrag = BarBedrag + ConsumptieBedrag

GOTO [BarLabel] END IF LET Naam$ = Voornaam$ + " " + Achternaam$ PRINT "Rekening voor " ; Naam$ PRINT "Bar: " ; BarBedrag END


Met als resultaat:

Wat is de voornaam van de klant?>Jan Wat is de achternaam van de klant?>Jansen Consumptie invoeren:>1.50 Consumptie invoeren:>1.50 Consumptie invoeren:>2.25 Consumptie invoeren:>3.10 Consumptie invoeren:>0 Rekening voor Jan Jansen Bar: 8.35

Opdracht: breid de flowchart uit voor de categorieën baanhuur en restaurant.

Opdracht: breid nu het programma uit naar aanleiding van de vorige opdracht gemaakte flowchart. Sla het op als rekening.bas.

De oplossing vind je op de volgende pagina.


INPUT "Wat is de voornaam van de klant?>" ; Voornaam$ INPUT "Wat is de achternaam van de klant?>" ; Achternaam$ CLS LET BarBedrag = 0 LET RestaurantBedrag = 0 INPUT "Baanhuur:>" ; Baanhuur [BarLabel]

INPUT "Bar:>" ; ConsumptieBedragBar IF ConsumptieBedragBar <> 0 THEN

LET BarBedrag = BarBedrag + ConsumptieBedragBar GOTO [BarLabel]

END IF [RestaurantLabel]

INPUT "Restaurant:>" ; ConsumptieBedragRestaurant IF ConsumptieBedragRestaurant <> 0 THEN

LET RestaurantBedrag = RestaurantBedrag + ConsumptieBedragRestaurant GOTO [RestaurantLabel]

END IF LET Naam$ = Voornaam$ + " " + Achternaam$ LET TotaalBedrag = Baanhuur + BarBedrag + RestaurantBedrag PRINT "Rekening voor " ; Naam$ ; " bedraagt: " ; TotaalBedrag ; " EUR" END

Let op het CLS statement (Clear Screen) na het invoeren van de voor en achternaam. Hierdoor wordt het scherm schoongeveegd.

Voorbeeld rekening:

Baanhuur:>22.25 Bar:>3.50 Bar:>2.25 Bar:>2.25 Bar:>3.50 Bar:>2.25 Bar:>0 Restaurant:>22.50 Restaurant:>16.50 Restaurant:>0 Rekening voor Jan Jansen bedraagt: 75 EUR

Opdracht: voeg commentaar toe in de code.


1.12 De array Giedrius vindt het programma al aardig lijken op wat hij in gedachten had. Maar de gespecificeerde rekening voldoet niet aan de voorwaarden van de belastingdienst. En dat is voor sommige klanten een probleem. Bijvoorbeeld klanten die de kegelbaan huren voor een personeelsfeest.

Om de rekening aan de voorwaarden van de belastingdienst te laten voldoen moet de omschrijving van alle posten erop worden weergegeven. Een oplossing is om alle omschrijvingen eerst in de computer te laten invoeren en vervolgens als lijst af te drukken. Maar per klant is het aantal posten natuurlijk niet altijd gelijk. Je gaat dan ook gebruikmaken van zogenaamde arrays.

Een array is een rij van gelijksoortige objecten zoals getallen of strings. Je geeft de positie in de lijst aan met een rangnummer, de zogenaamde INDEX. De plaats wordt aangegeven tussen haakjes na de variabele. Dus bijvoorbeeld A(1) is de variabele op plaats 1, A(2) op plaats 2 enzovoort.

Als voorbeeld berekenen we de tafel van 23 in een array en drukken deze vervolgens af.

LET Teller = 1 [Vullen]

REM Eerst wordt de array gevuld zodat de variabele op de locatie 1, Waarde(1) gelijk is aan 1 * 23, REM Waarde(2) gelijk aan 2 * 23 enz.

LET Waarde(Teller) = Teller * 23 REM Teller wordt opgehoogd LET Teller = Teller + 1 REM Zo lang de teller kleiner of gelijk (<=) aan 10 is ga je door... IF Teller <= 10 THEN GOTO [Vullen] LET Teller = 1 [Printen] PRINT Teller ; " * " ; 23 ; " = " ; Waarde(Teller) LET Teller = Teller + 1 IF Teller <= 10 THEN GOTO [Printen] END Opdracht: tik dit programma in, test het en sla het op als array.bas.

1.13 De FOR NEXT-statement Herhalingen zijn tot nu toe gemaakt met een GOTO-statement. De GOTO springt naar een regelnummer of naar een label. Er zijn echter speciale statements om operaties te herhalen, ook wel ‘loopstatements genoemd’. De eerste die hier wordt behandeld is de zogenaamde FOR ... NEXT.

De constructie met een label zoals hiervoor gebruikt wordt over het algemeen uitgevoerd met een FOR NEXT-statement. Hiermee kun je een opdracht een aantal keren herhalen.

FOR Teller = 1 TO 10 (Code die 10 keer moet worden herhaald) NEXT Teller Het bovenstaande programma ziet er dan als volgt uit. FOR Teller = 1 TO 10 LET Waarde(Teller) = Teller * 23 NEXT Teller


FOR Teller = 1 TO 10 PRINT Teller ; " * " ; 23 ; " = " ; Waarde(Teller) NEXT Teller Dit is dan de uitvoer van dit programma. 1 * 23 = 23 2 * 23 = 46 3 * 23 = 69 4 * 23 = 92 5 * 23 = 115 6 * 23 = 138 7 * 23 = 161 8 * 23 = 184 9 * 23 = 207 10 * 23 = 230 Je kunt dus ook in een loop een willekeurig aantal waarden binnenhalen. Het volgende programma slaat woorden die je invoert op en blijft net zo lang doorvragen tot je een lege regel invoert. Dan worden de ingevoerde woorden geprint.

LET AantalWoorden = 0 [Invoeren] INPUT "Woord?>" ; WoordInvoer$ REM geen lege regel! IF WoordInvoer$ <> "" THEN REM Invoer is een woord LET AantalWoorden = AantalWoorden + 1 LET WoordArray$(AantalWoorden) = WoordInvoer$ GOTO [Invoeren] END IF REM Invoer is een lege regel FOR Teller = 1 TO AantalWoorden PRINT "Woord(";Teller;") = ";WoordArray$(Teller) NEXT Teller END

De uitvoer ziet er als volgt uit.

Woord?>Aap Woord?>Noot Woord?>Mies Woord?>Zus Woord?>Jet Woord?>Teun Woord?>Vuur Woord?> Woord(1) = Aap Woord(2) = Noot Woord(3) = Mies Woord(4) = Zus


Woord(5) = Jet Woord(6) = Teun Woord(7) = Vuur

Opdracht: tik dit programma in, test het en sla het op als aapnootmies.bas. Werk het ook uit in een flowchart. Opdracht: pas nu het programma voor het rekeningoverzicht voor de kegelbaan zodanig aan dat je de volgende dialoog en rekening krijgt.

Voornaam:>Jan Achternaam:>Jansen Baanhuur:>22.25 Bar consumptie:> bier Bedrag:>2.25 Bar consumptie:> wijn Bedrag:>3.25 Bar consumptie:> bier Bedrag:>2.25 Bar consumptie:> wijn Bedrag:>3.25 Bar consumptie:>0 Restaurant consumptie:> biefstuk met brood Bedrag:>13.50 Restaurant consumptie:> schnitzel met frites Bedrag:>11.50 Restaurant consumptie:>0 (Scherm wordt schoongemaakt m.b.v. CLS.) De rekening ziet er dan als volgt uit. Naam klant: Jan Jansen Baanhuur: 22.25 Bier - 2.25 Wijn - 3.25 Bier - 2.25 Wijn - 3.25 Bar Totaal: 11 Biefstuk met brood - 13.50 Schnitzel met frites - 11.50 Restaurant Totaal: 25 Totaal rekening: 58.25 Aanwijzing: om dit te bereiken moet de hele geschiedenis van omschrijvingen en bedragen in de computer worden opgeslagen. Een manier om dat te doen ziet er als volgt uit (probeer de code te volgen).

INPUT "Wat is de voornaam van de klant?>" ; Voornaam$ INPUT "Wat is de achternaam van de klant?>" ; Achternaam$ LET BarBedragTotaal = 0 LET RestaurantBedragTotaal = 0 LET AantalConsumptiesBar = 0


LET AantalConsumptiesRestaurant = 0 INPUT "Baanhuur:>" ; Baanhuur [BarLabel] INPUT "Bar consumptie>"; BarConsumptie$ IF BarConsumptie$ <> "" THEN LET AantalConsumptiesBar = AantalConsumptiesBar + 1 LET BarConsumpties$(AantalConsumptiesBar) = BarConsumptie$ INPUT "Bedrag:>" ; ConsumptieBedragBar LET BarConsumptieBedragen(AantalConsumptiesBar) = ConsumptieBedragBar GOTO [BarLabel] END IF [RestaurantLabel] INPUT "Restaurant consumptie>"; RestaurantConsumptie$ IF RestaurantConsumptie$ <> "" THEN LET AantalConsumptiesRestaurant = AantalConsumptiesRestaurant + 1 LET RestaurantConsumpties$(AantalConsumptiesRestaurant) = RestaurantConsumptie$ INPUT "Bedrag:>" ; ConsumptieBedragRestaurant LET RestaurantConsumptieBedragen(AantalConsumptiesRestaurant) = ConsumptieBedragRestaurant GOTO [RestaurantLabel] END IF PRINT "Naam klant: "; Voornaam$ ; " " ; Achternaam$ PRINT "Baanhuur : " ; Baanhuur FOR Teller = 1 TO AantalConsumptiesBar PRINT BarConsumpties$(Teller) ; " - " ; BarConsumptieBedragen(Teller) LET BarBedragTotaal = BarBedragTotaal + BarConsumptieBedragen(Teller) NEXT Teller PRINT "Bar totaal : " ; BarBedragTotaal FOR Teller = 1 TO AantalConsumptiesRestaurant PRINT RestaurantConsumpties$(Teller) ; " - " ; RestaurantConsumptieBedragen(Teller) LET RestaurantBedragTotaal = RestaurantBedragTotaal + RestaurantConsumptieBedragen(Teller) NEXT Teller PRINT "Restaurant totaal : " ; RestaurantBedragTotaal PRINT "Totaal rekening : " ; Baanhuur + BarBedragTotaal + RestaurantBedragTotaal END

1.14 Printen van de bon Ten slotte moet de rekening worden afgedrukt. Dat gebeurt met het statement LPRINT. Dit werkt precies hetzelfde als het statement PRINT. Alleen in plaats van naar het scherm wordt de uitvoer naar de standaardprinter gestuurd. Op de virtuele machine die bij dit boek wordt gebruikt, is geen echte printer in gebruik. Om een printer te simuleren wordt gebruikgemaakt van XPS. Hiermee kun je een printerafdruk opslaan in een bestand met de extensie .xps.

Opdracht: pas het voorgaande programma zodanig aan dat het de rekening naar de printer afdrukt in plaats van naar het scherm.

Als je het programma uitvoert dan zie je het volgende verschijnen.


Je vult de naam van het xps bestand in. Bijvoorbeeld test.xps op de desktop. Als je nu het bestand test.xps opent (dubbelklik), dan zie je het volgende venster openen.


Een bon, zoals deze er op een printer uit zal zien.

1.15 Maken van een nette uitdraai De rekening moet nu in een net lijstje worden gepresenteerd. Het netjes presenteren van tekst wordt ook wel formatteren genoemd.

Naam klant: Jan Jansen Baanhuur: € 22.25 Bier € 2.25 Wijn € 3.25 Bier € 2.25 Wijn € 3.25 Bar Totaal € 11.00 Biefstuk met brood € 13.50 Schnitzel met frites € 11.50 Restaurant Totaal € 25.00 Totaal € 58.25 Dank u wel voor het gebruik van onze kegelbaan!


Opdracht: pas het programma zodanig aan dat het de uitvoer presenteert zoals in het voorbeeld. Je kunt gebruikmaken van het TAB-statement. Maak gebruik van de uitgebreide help functie van BASIC om de werking van het TAB-statement te begrijpen.

1.16 USING Met behulp van het USING-statement kan ook worden gezorgd dat getallen altijd met een vast aantal cijfers voor en achter de komma worden afgedrukt. Dit gebeurt door de getallen in een string te kopiëren volgens een bepaald voorschrift. Dat voorschrift wordt voorgesteld door een string met hekjes. Als je bijvoorbeeld drie cijfers voor de komma wilt en twee achter de komma, dan ziet deze string er als volgt uit.“###.##”.

Het USING-statement wordt dan als volgt gebruikt.

In plaats van

PRINT getal

Gebruik je:

LET Getal_als_string = USING (“###.##” , getal) PRINT Getal_als_string

Opdracht: zorg er nu voor dat alle bedragen ook worden afgedrukt met drie decimalen voor en twee decimalen achter de decimale punt.

1.17 Het maken van en werken met een executable Een executable is een programma dat je afzonderlijk kunt gebruiken. Je hoeft daarvoor dus niet eerst Just BASIC op te starten en de code te laden. Je kunt een executable bijvoorbeeld op je bureaublad zetten waarna je het door erop te dubbelklikken kunt uitvoeren (Engels: to execute). Het gebruik van een executable is daardoor veel overzichtelijker voor een gebruiker.

Wel moet je realiseren dat een executable die je maakt vanuit Just BASIC, eigenlijk nog wel Just BASIC zelf nodig heeft. Alleen wordt Just BASIC zelf onzichtbaar gehouden en zie je, als je de executable uitvoert, alleen het programmavenster verschijnen.

Voor elke taal is het maken van een executable verschillend. Met Just BASIC gaat het maken van een executable als volgt.

1 Maak eerst een map aan waarin je alles wat nodig is voor je programma op gaat slaan. Bijvoorbeeld c:\BonPrint.

2 Maak nu een ‘tokenized file’ van je programma. Als je je programma in Just BASIC hebt geladen, dan ga je naar menu RUN – Make *.TKN File. Sla het bestand op als bon.tkn in de map c:\BonPrint.

3 Kopieer de volgende bestanden nu van C:\BASIC\Just BASIC v1.01 naar de map c:\BonPrint. (dus niet verplaatsen!) • vbas31w.sll • vgui31w.sll • voflr31w.sll


• vthk31w.dll • vtk1631w.dll • vtk3231w.dll • vvm31w.dll • vvmt31w.dll • JBRUN101.EXE

4 Hernoem nu JBRUN101.EXE naar Bon.exe (zelfde naam als je tkn-bestand). 5 Selecteer Bon.exe en sleep met je rechtermuisknop ingedrukt naar je bureaublad. Laat het daar

los en selecteer uit het menu dat je ziet, Create Shortcuts Here. Je maakt nu een verbinding vanaf je bureaublad naar je programma. De tekst bij het icoon is: Bon.exe – Shortcut. Hernoem dit naar Bon.

Dubbelklik nu op het zojuist gemaakte icoon op je bureaublad en je programma opent.

Opdracht: maak ook een shortcut naar je startmenu.


2 Verder met BASIC

2.1 Menugestuurd programma Het bonnenprogramma is in gebruik en werkt op zich wel goed. Maar in de praktijk blijkt dat er veel tikfouten worden gemaakt met de omschrijvingen en prijzen. Het personeel zou liever zien dat men de consumpties kan kiezen uit lijstjes (menu’s), zoals in het voorbeeld.

Welkom Baan nummer (0 = stop)>2 Baan nummer 2 0 Terug 1 Bar 2 Restaurant 3 Rekening afdrukken >1 Als bijvoorbeeld 2 wordt ingetikt, dan verschijnt een ander menu.

Baan nummer 2 0 Terug 1 Bier 2 Wijn 3 Gedistilleerd 4 Fris >2 Door het intikken van 2 wordt 1 wijn geboekt op baan nummer 2.

Op deze manier worden dan alle bestellingen opgenomen en kan aan het eind van het kegelen de rekening worden opgemaakt.

Het maken van het programma heb je uitbesteed aan Peter, een ervaren BASIC-programmeur. Jij wordt echter wel verantwoordelijk voor het onderhoud van het programma. De programmeur gebruikt een aantal technieken die nog niet zijn behandeld. We gaan die aan de hand van zijn code bekijken.

Opdracht: open het programma KegelbaanPOS.bas (zit in installatie map JBasic), voer het uit en bekijk hoe het functioneel in elkaar zit door alle menu’s te proberen.

Opdracht: bekijk nu de code. Welke statements/onderdelen zijn nieuw voor je? Maak hiervan een lijst. Hierna gaan we de nieuwe onderdelen een voor een doorwerken.

2.2 Nieuwe BASIC-statements De programmeur is bij het maken van het programma uitgegaan van de volgende randvoorwaarden.

• Er zijn vijf kegelbanen. • Er zijn drie hoofdacties.

o Consumptie boeken voor de bar o Consumptie boeken voor het restaurant


o Bon maken. Als de bon is gemaakt, dan wordt de rekening schoongemaakt. • Vanuit alle menu’s kun je een niveau terugspringen.

Het eerste dat opvalt is dat het woord LET overal in het programma consequent is weggelaten. Het is namelijk niet verplicht (a = b is dus hetzelfde als LET a = b). Vanaf nu zullen we de LET overal weglaten.

2.3 Declaraties Boven in het programma zie je statements opgeslagen die je in de verschillende programmamenu’s wilt gebruiken. Categorie$() bewaart de waarden van je top menu-items. Voor de bar en voor het restaurant zijn er telkens een tweetal arrays: een met de namen Bar$() en Restaurant$() en een met de prijzen BarPrijs() en RestaurantPrijs(). Er zijn nog twee andere variabelen die een waarde hebben gekregen, namelijk WAAR en ONWAAR. Dat is gedaan om in het programma duidelijk aan te geven wat de bedoeling is bij verschillende beslissingen. Bijvoorbeeld om door te gaan met een loop. Vaak wordt ook gebruikgemaakt van de variabelen TRUE en FALSE.

2.4 GOSUB RETURN In plaats van GOTO te gebruiken is in het programma gebruikgemaakt van GOSUB. Met GOSUB kun je, net als met GO TO naar een label of een regelnummer springen. Het verschil is dat vanuit de code onder het label met een RETURN terug wordt gesprongen naar het volgende statement onder de GOSUB. Er hoeft dus geen label te worden gemaakt om vanuit de GOSUB terug te springen.

2.5 AND (OR en NOT) In het volgende codefragment is in het IF-statement gebruikgemaakt van een AND om twee condities te combineren waaraan allebei moet worden voldaan.

INPUT ">";CategorieKeuze IF CategorieKeuze >= 1 AND CategorieKeuze <= 4 THEN

Dit betekent: de ingevoerde variabele CategorieKeuze moet liggen tussen 1 en 4. AND wordt een logische operator genoemd. Andere logische operatoren zijn OR (of) en NOT (niet). Is het zo dat met een AND aan beide voorwaarden moet worden voldaan, bij een OR moet aan een van beide voorwaarden worden voldaan. De NOT keert de logische waarde om. Dus als bijvoorbeeld (a < b) waar is, dan is NOT(a < b) onwaar. Opdracht: gebruik het volgende codefragment om alle mogelijkheden (AND, OR en NOT) te testen. INPUT a INPUT b IF (a < 2 AND b>= 5) THEN PRINT “Conditie waar” ELSE PRINT “Conditie onwaar” END IF

2.6 DO LOOP en andere loopstructuren Op verschillende plekken zie je de DO LOOP. Alle code tussen de DO en de LOOP wordt herhaald. In dit geval zo lang aan de conditie die in de WHILE staat is voldaan (bijvoorbeeld WHILE DoorgaanTop = WAAR).


Op deze plek zou je ook een UNTIL kunnen gebruiken in plaats van een WHILE. De loop wordt dan herhaald totdat aan de UNTIL is voldaan. In dit geval zou dat dan zijn: UNTIL DoorgaanTop = ONWAAR. In bovenstaand voorbeeld is de conditie achter het Loop-statement gezet. Het mag ook achter de DO worden gezet. DO WHILE <conditie> <statements> LOOP DO UNTIL <conditie> <statements> LOOP Het verschil is dat bij het deze laatste twee voorbeelden de conditie wordt getest voordat de statements in de loop worden uitgevoerd. Bij plaatsing van de conditie achter de LOOP wordt getest aan het eind van de statements. Deze wordt dus altijd minimaal één keer doorlopen. Je kunt loops ook voortijdig beëindigen, dus voordat de conditie aan het begin of eind wordt gebruikt. Dat doe je met het statement EXIT. DO <statements> IF <andere conditie> THEN EXIT DO LOOP WHILE <conditie> Opdracht: gebruik het volgende codefragment om alle loop structuren te testen. (Maak hierbij gebruik van de helpfunctie van BASIC. Selecteer hiervoor Just BASIC Help in het Help menu.) INPUT "Welke tafel?>";Basis Teller = 0 DO Teller = Teller + 1 PRINT Teller; " X "; Basis; " = "; Teller * Basis LOOP UNTIL Teller = 10 END

2.7 SELECT CASE Het volgende nieuwe statement is de SELECT CASE. Dit is een uitbreiding van de IF THEN ELSE. Met dit statement kun je, afhankelijk van de waarde van een variabele naar een CASE springen.

De meest algemene vorm is de volgende. SELECT CASE var CASE x

<statements-1> CASE y

<statements-2> CASE z

<statements-3> CASE ELSE

<statements-4>


END SELECT Als variabele var = x dan worden statements-1 uitgevoerd, bij var = y, statements-2 enzovoort. Ten slotte: als var geen van de waarden in de CASE lijst heeft, dan wordt de ELSE uitgevoerd.

2.8 STOP Je gebruikt STOP-statement om het programma te stoppen. Het is eigenlijk hetzelfde als het END-statement. Als je geen STOP-statement had gezet in het programma, dan zou bij keuze van 0 in het hoofdmenu het programma doorgaan met de statements die onder de LOOP WHILE staan.

2.9 DUMP Bij het afdrukken van de bon maak je gebruik van de LPRINT. Dit statement stuurt telkens een regel naar de standaardprinter van de computer. Om aan te geven dat de printer mag beginnen met afdrukken, moet je het DUMP-statement gebruiken.

2.10 Aanpassingen aan het programma Omdat jij verantwoordelijk bent voor het onderhoud van het programma, krijg je een aantal opdrachten van John.

Opdracht: Giedrius is niet tevreden met de opmaak van de bon. De verschillende items zijn niet netjes uitgelijnd. Jij moet ervoor zorgen dat de items op de bon netjes zijn uitgelijnd en dat de prijzen en totalen onder elkaar staan.

Opdracht: in de bar en het restaurant zijn de prijzen verhoogd. Alle consumpties van de bar gaan omhoog met € 0,20 en alle consumpties van het restaurant met € 0,50. De huur van de kegelbaan wordt verhoogd met € 1,50 per uur.

Opdracht: het assortiment wordt uitgebreid. Er komt onderscheid tussen tapbier en flesjes bier. De prijs van tapbier wordt € 2,45 en een flesje bier kost € 2,95. Daarnaast wordt het gedistilleerd verdeeld in Gedistilleerd (laag) en Gedistilleerd (hoog). Voor gedistilleerd laag blijft de prijs gelijk (€ 3,45). Voor Gedistilleerd (hoog) wordt de prijs € 3,95.

Opdracht: binnenkort wordt het kegelcentrum uitgebreid met drie banen tot een totaal van acht banen. Vooruitlopend hierop wil Giedrius alvast het programma door jou laten aanpassen. Zolang de banen nog niet klaar zijn, moet het programma nog werken voor vijf banen. Je kunt het wel alvast testen voor de nieuwe situatie met acht banen. Zorg ervoor dat, door het veranderen van een enkele variabele boven in, het aantal banen kan worden veranderd van vijf naar acht.

2.11 Meerdimensionale arrays Met het aanpassen van het aantal kegelbanen is het je waarschijnlijk opgevallen dat de code die je erbij moest maken alleen verschilde in het baannummer: [RekeningBaan1], [RekeningBaan2] enzovoort. De rest van de code is helemaal gelijk. Je besluit om gebruik te maken van tweedimensionale arrays om van de [RekeningBaanN]-labels één versie te maken.

Een tweedimensionale array is een array met twee indexen. Als voorbeeld hiervan bespreken we een programma om de tafels van 1 tot en met 5 op te slaan, en daarna af te drukken.

FOR Tafel = 1 TO 5 FOR Teller = 1 TO 10


Resultaat(Teller,Tafel) = Teller * Tafel NEXT Teller NEXT Tafel FOR Tafel = 1 TO 5 PRINT "Tafel van "; Tafel FOR Teller = 1 TO 10 PRINT Teller;" X ";Tafel; " = "; Resultaat(Teller,Tafel) NEXT Teller NEXT Tafel

In de tweedimensionale array Resultaat(Teller, Tafel) worden 10 maal 10 resultaten opgeslagen. Je zou de resultaten als volgt in een tabel kunnen weergeven.

1 2 3 4 5 6 7 8 9 10 1 1 2 3 4 5 6 7 8 9 10 2 2 4 6 8 10 12 14 16 18 20 3 3 6 9 12 15 18 21 24 27 30 4 4 8 12 16 20 24 28 32 36 40 5 5 10 15 20 25 30 35 40 45 50

Opdracht: pas bovenstaand programma zodanig aan dat het deze tabel kan afdrukken.

Opdracht: pas nu het KegelbaanPOS-programma zodanig aan dat de code voor het afdrukken niet steeds wordt herhaald. Tip: je kunt hier het best gebruikmaken van tweedimensionale arrays voor de arrays BarBaan en RestaurantBaan.

2.12 Data opslaan in bestanden Het personeel dat het programma gebruikt heeft nog een wens voor een aanpassing. Het wilt graag willen dat de bonnen die worden afgedrukt ook in een bestand kunnen worden opgeslagen. Giedrius besluit aan deze wens tegemoet te komen en geeft jou de opdracht om een uitbreiding te maken zodat dat een gebruiker een bon kan opslaan onder een door hem/haar gekozen naam. Je besluit de bonnen op te slaan in de map c:\bonnen.

Hoe gaat het opslaan van gegevens nu precies in zijn werk? Hieronder volgt een voorbeeld.

1 INPUT “Bestandsnaam?>”; Filenaam$ 2 INPUT “Bestandsinhoud?>”;Inhoud$ 3 Pad$ = "c:\bonnen\" 4 Extentie$ = ".txt" 5 Filenaam$ = Pad$ + Filenaam$ + Extentie$ 6 OPEN Filenaam$ FOR OUTPUT AS #outputfile 7 PRINT #outputfile, Inhoud$ 8 CLOSE #outputfile 9 END In regel 1 wordt de bestandsnaam aan de gebruiker gevraagd. Vervolgens wordt in regel 2 gevraagd wat de inhoud van het bestand moet zijn. In regel 5 wordt de bestandsnaam gecombineerd met het pad (de map waar het bestand in moet worden opgeslagen) en het bestandstype ‘.txt’.


Nu kan in regel 6 het bestand worden geopend. De variabele #outputfile wordt de filehandle genoemd en dat is de bestemming waarin wordt geprint met een PRINT-statement. Dat PRINT-statement krijgt als eerste variabele de filehandle mee van het bestand waar naar moet worden geprint.

Opdracht: test het besproken programma. Voer een bestandsnaam en bestandsinhoud in en controleer of in map c:\bonnen inderdaad het ingevoerde bestand staat. Controleer met Kladblok of de inhoud overeenkomt met de ingevoerde inhoud. Controleer ook wat er gebeurt als je het programma opnieuw uitvoert.

Opdracht: breid het KegelbaanPOS programma uit met de volgende twee Sub’s. • RekeningOpslaan: in deze Sub wordt de rekening opgeslagen naar een door de gebruiker op te

geven bestand. • RekeningAfsluiten: in deze Sub wordt de rekening van een baan gesloten. In de vorige versie

gebeurde dat automatisch aan het eind van de afdruksub. Controleer dat en verwijder de functionaliteit daar.

2.13 SUB en FUNCTION Giedrius is tevreden over het programma maar merkt wel op dat het onhandig is dat sommige variabelen door het hele programma gebruikt kunnen worden. Daardoor liggen vergissingen voor de hand. Daarom stelt Giedrius voor om gebruik te gaan maken van functies en subroutines.

Functies en subroutines zijn als kleine afgescheiden stukken programma. Zij bieden een aantal voordelen.

• Om te beginnen zijn ze herbruikbaar. Maar dat voordeel hebben stukken code die voor een GOSUB zijn geschreven ook.

• De variabelen die binnen een subroutine worden gebruikt, zijn lokaal. Buiten de body van de routine bestaan ze niet. Ze kunnen dus ook niet per ongeluk een andere waarde krijgen vanuit een ander stuk code.

• Je kunt aan functies en subroutines waarden meegeven die deze moeten gebruiken om hun taak uit te voeren.

Door het gebruik van subroutines en functies zal het programma veel overzichtelijker van opzet worden en dus ook beter te onderhouden zijn.

We zullen beginnen met het maken van enkele voorbeelden. Eerst een functie. We noemen deze functie InclusiefBTW. Deze functie berekent het bedrag inclusief btw van een als parameter meegegeven bedrag.

De functie ziet er als volgt uit.

FUNCTION InclusiefBTW (ExclusiefBTW, BTWPercentage) BTW = BTWPercentage * ExclusiefBTW / 100 InclusiefBTW = ExclusiefBTW + BTW

END FUNCTION

De ‘body’ van de functie staat tussen FUNCTION en END FUNCTION.


Achter FUNCTION staat de functienaam, in dit geval InclusiefBTW. Daarachter tussen haken een of meer parameters, gescheiden door komma’s. In dit geval zijn dat de getallen ExclusiefBTW en BTWPercentage. De berekening van het bedrag inclusief btw vindt plaats in de body van de functie.

De functie kan als volgt worden aangeroepen.

INPUT "Bedrag?";Bedrag INPUT "BTW percentage?";BTW Inclusief = InclusiefBTW(Bedrag , BTW) PRINT Inclusief END

Opdracht: maak een functie die alle gehele getallen tussen twee gegeven getallen optelt. Noem deze functie SomReeks. Voorbeeld: SomReeks(3,7) berekent 3+4+5+6+7 en geeft dus 25 als resultaat. Test de functie in een programma. Subroutines verschillen van functies omdat dat ze geen waarde teruggeven. Ze worden dan ook vaak gebruikt om een taak uit te voeren waarbij dat niet nodig is. Denk aan het opslaan van variabelen naar een bestand of het creëren van uitvoer naar het scherm of een printer.


3 Aan de slag met Java Jouw bonnenprogramma wordt nu al weer enige tijd gebruikt door het personeel van AmeRijck. Zelfs met zoveel succes dat aan jou wordt gevraagd om nog een aantal andere programma’s te ontwikkelen. Bij AmeRijck heeft men echter besloten om over te stappen op een standaardprogrammeertaal: Java. Dat betekent dat je deze programmeertaal moet gaan leren.

Giedrius legt uit dat Java een zogenaamde object georiënteerde programmeertaal is. Samen met Giedrius besluit je om het leren van object georiënteerd programmeren te combineren met het leren van Java.

Het eerste wat je gaat doen, is een klein testprogramma maken. De afdeling Systeembeheer heeft de taal Java klaargezet zodat je meteen kunt beginnen.

Je maakt een map aan op de computer met de naam c:\Java en opent nu een dosvenster om een eerste programma te maken. Dat gaat als volgt.


Je tikt daarna het volgende in het dosvenster.

cd \<enter> mkdir Java<enter> cd Java<enter>

Daarna tik je notepad<enter> waardoor het kladblok geopend wordt.


In kladblok tik je de volgende tekst.

class HelloWorldApp { public static void main(String[] args) { System.out.println("Hello World!"); } }


Daarna wordt het programma opgeslagen in de map c:\Java onder de naam HelloWorldApp.Java, waarna het kladblok wordt afgesloten.

Let goed op! Java is hoofdlettergevoelig (case sensitive). Dat betekent bijvoorbeeld dat String iets anders betekent dan string. Immers de eerste is met een hoofdletter geschreven, de tweede niet.

Met dir<enter> controleer je of er inderdaad een bestand staat. Daarna tik je het volgende commando.

Javac HelloWorldApp.Java<enter>

Nu tik je in:

Java HelloWorldApp<enter>

waarna de tekst "Hello World!" verschijnt.

Met de opdracht dir<enter> blijkt dat er een bestand is bijgekomen, namelijk HelloWorldApp.class.


Je vraagt aan Giedrius: ‘Wat is hier allemaal gebeurd?’

Giedrius legt het uit.

Een dosvenster wordt gebruikt om commando’s in te voeren zoals je weet. We zijn begonnen met een nieuwe map aan te maken onder de C-partitie. Die map heet Java en via cd Java ga je in die map staan. Via het commando notepad open je het kladblok waarin je tekst kunt intikken.

De ingetikte tekst is in feite je eerste Javaprogramma. We noemen dat broncode omdat de computer deze code niet rechtstreeks kan interpreteren. Bij BASIC was dat anders. Daar kon dat wel. Verreweg de meeste programmeertalen werken zoals Java. Je moet de broncode eerst ‘compileren’: dat betekent dat je de broncode leesbaar maakt voor de computer. De Javacompiler heet Javac en deze maakt een nieuw bestand aan op basis van de broncode.

Het broncode bestand heet HelloWorldApp.Java, het door de compiler aangemaakte bestand heet HelloWorldApp.class. in tegenstelling tot HelloWorldApp.Java is HelloWorldApp.class niet leesbaar voor ons maar wel voor de computer. Dat ziet er als volgt uit.


We noemen dat hexadecimale code. Vandaar het laatste commando: Java HelloWorldApp. Hier wordt aan Java gevraagd om het bestand HelloWorldApp.class uit te voeren. En dat gebeurt dus, waardoor de tekst "Hello World!" op het scherm verschijnt.

3.1 De broncode Allereerst zie je veel accolades, { en }. Tussen een open { en sluit } accolade wordt code geschreven die als een opdracht (statement) moeten worden gezien.

Verder is Java object georiënteerd. Het programma zelf wordt gevormd door een klasse genaamd HelloWorldApp.

De hoofdstructuur van dit programma is dus als volgt.

class HelloWorldApp { ..... }

Java is wel hoofdlettergevoelig (case sensitive), maar niet regelgevoelig. Er mogen meer statements (opdrachten) op een regel. Er mogen zelfs extra regels worden gevoegd tussen statements of binnen een statement.

class HelloWorldApp { ..... }


is dus hetzelfde als

class HelloWorldApp { ..... } of

class HelloWorldApp{ ..... }

De class is alleen een constructie om het programma zelf in te maken. In de class moet nu nog een actief deel worden aangemaakt. Dat is hier het eigenlijke programma. Voor HelloWorldApp.Java zelf heeft dat de volgende vorm.

public static void main(String[] args) { ... }

Zodat je krijgt:

class HelloWorldApp {

public static void main(String[] args) { ... }

}

Het belangrijkste is hier het label main(...). Dat is als het ware de ingang van het programma. Java zoekt bij het commando Java HelloWorldApp naar deze tekst. Het moet dus altijd aanwezig zijn in een Javaprogramma en er mag er ook maar één van zijn.

De voorvoegsels public static void bespreken we later nog, evenals de (String[] args) die achter main staat.

Tussen de accolades van main vindt Java in dit geval één statement:

System.out.println("Hello World!");

Als eerste zie je dat het statement wordt afgesloten met een ;. Dat markeert het einde van een statement.

Het statement System.out.println("Hello World!") drukt de zin "Hello World!" af in het dosvenster.


Het onderdeel println(...) (van print line) betekent dat het afgedrukt wordt als een regel, out betekent dat het output (uitvoer) is en System geeft aan dat het om een systeemfunctie van Java gaat. De te printen tekst bevindt zich tussen stringquotes (“…”).

3.2 Verder experimenteren Giedrius en jij besluiten nog wat verder te experimenteren. Giedrius tikt het volgende programma in in kladblok.

class PrintArgsApp { public static void main(String[] args) { int i; for(i = 0; i < args.length; i++) System.out.println(args[i]); } }

Hij slaat het op in de map c:\Java onder de naam PrintArgsApp.Java en compileert het.

Daarna tikt hij in: Java PrintArgsApp aap noot mies wim zus jet<enter>

Het resultaat is:

Giedrius legt de werking van de code uit.

Achter het label main zie je staan: (String[] args). Dat zijn zogenaamde argumenten die vanuit het commando in het dosvenster worden doorgegeven. Ze nemen altijd de vorm aan van een string (vandaar “String”) en worden doorgegeven in de vorm van een array. Dat laatste wordt dan weer aangegeven door String[].


Om ze allemaal te printen moet je de lengte van de array weten. Die kun je opvragen met args.length.

De argumenten worden afgedrukt in een loop. In Java heeft een loop de volgende vorm.

for(<variabele> = <startwaarde>; <conditie om door te gaan>; <aanpassing variabele>) Statement;

In ons geval betekent dit het volgende.

<variabele> = <startwaarde> Wij beginnen met een variabele genaamd i die als startwaarde 0 heeft.

<conditie om door te gaan> zolang i kleiner is dan args.length (de lengte van de args array) moet de loop opnieuw worden uitgevoerd.

Wel even opletten dat Java arrays beginnen bij index 0 (args[0]). Als de lengte dus, zoals in dit geval zes is, moet je stoppen bij vijf (omdat args[0], args[1], args[2], args[3], args[4] en args[5] in totaal zes elementen zijn. Vandaar dus het kleiner-dan teken in i<args.length.

Onder <aanpassing variabele> staat i++. In Javatermen betekent dat: hoog i elke keer dat de loop is doorlopen op met 1 (je had ook i=i+1 kunnen gebruiken). Wanneer i groter of gelijk is aan args.length, moet de loop stoppen.

Samengevat: met onze argumentenlijst (aap noot…) wordt de loop zes keer doorlopen en telkens wordt de string door System.out.println(args[i]); afgedrukt op het scherm. Als je meer statements binnen de loop wilt zetten, moet je accolades gebruiken. Dit doe je op de volgende manier. for(<variabele> = <startwaarde>; <conditie om door te gaan>; <aanpassing variabele>) { Statement1; Statement2; Statement3;

} Voor het voorbeeld zou dat dan betekenen: for(i = 0; i < args.length; i++) { System.out.println(args[i]); }


Het is beter om je aan te leren om altijd accolades te gebruiken. Het is duidelijker en je kunt geen vergissing maken als je statements aan de loop wilt toevoegen. Tot slot zie je boven aan nog staan: int i;. Dat is een declaratie van de variabele i. Bij Java moet van elke variabele die je wilt gebruiken, van tevoren worden opgeven wat het type is. In ons geval is i van het type int (integer, ofwel geheel getal).

Java kent onder andere de volgende types variabelen. byte • een kleine integer (8 bits) • minimumwaarde is z128 • maximumwaarde is 127

short • grotere integer (16 bits). • minimumwaarde is -32,768 • maximumwaarde is 32,767

int • standaard integer (32 bits) • minimum aarde is - 2,147,483,648 • maximumwaarde is 2,147,483,647

long • heel grote integer (64 bits) • minimumwaarde is -9,223,372,036,854,775,808 • maximumwaarde is 9,223,372,036,854,775,807

float • klein getal met decimale punt (32 bits)

double • groot getal met decimale punt (64 bits)

boolean • boolean datatype (1 bit) • bestemd om alleen True of False aan te geven

char • bestemd om een karakter in op te slaan (16 bits) • hierin kunnen zeer veel (ongeveer 65000) verschillende karakters worden opgeslagen zoals ons

(Latijnse) alfabet, maar bijvoorbeeld ook Chinese en Japanse karakters

string • bestemd om een rij van karakters (van het type char) in op te slaan


3.3 Meer Java Giedrius legt uit dat Java ongeveer dezelfde programmeer structuren kent als BASIC. Alleen zien ze er anders uit. Hij maakt de volgende opsomming.

3.4 If then else De syntax voor dit statement is:

if … else … Het else-deel is niet verplicht. Uiteraard is het beter om de statements (…) weer binnen accolades te plaatsen zodat je de volgende structuur krijgt. if {

…. } else {

… } Het volgende voorbeeld laat zien hoe dit gaat. public class TestGetallen { public static void main(String[] args) { int EersteGetal = Integer.parseInt(args[0]); int TweedeGetal = Integer.parseInt(args[1]); if (EersteGetal != TweedeGetal) { System.out.println("Eerste getal is ongelijk aan tweede getal."); } if (EersteGetal < TweedeGetal) { System.out.println("Eerste getal is kleiner dan tweede getal."); } if (EersteGetal == TweedeGetal) { System.out.println("Eerste getal is gelijk aan tweede getal."); } if (EersteGetal > TweedeGetal) { System.out.println("Eerste getal is groter dan tweede getal."); } }


} De twee invoergetallen worden hier getest op het volgende. • Ongelijk (!=) hetgeen betekent not (!) equal (=). • Kleiner dan (<). • Gelijk (==) hetgeen betekent ‘is equal’ (==). Let op dat dit wordt aangegeven met een dubbel is

gelijkteken. • Groter dan (>).

Opmerking: het statement Integer.parseInt(args[0]); zorgt ervoor dat args[0] (van het type String) wordt omgezet in een variabele van het type integer.


3.5 Het switchstatement Met dit statement kan worden gekozen uit verschillende opties. Vanuit switch wordt gesprongen naar de case die gelijk is aan het label. Via de break wordt naar het einde gesprongen.

//In dit voorbeeld wordt de naam van een maand (maandString) gezocht bij een nummer. public class MaandNaam { public static void main(String[] args) { //Hier wordt het maandnummer bepaald vanuit het meegegeven argument. int maand = Integer.parseInt(args[0]); String maandString; //Als de variabele “maand” ligt tussen 1 en 12 dan wordt naar de bijbehorende //case gesprongen. Als de variabele niet tussen 1 en 12 ligt, dan treedt de default //in werking. switch (maand) { case 1: maandString = "Januari"; break; case 2: maandString = "Februari"; break; case 3: maandString = "Maart"; break; case 4: maandString = "April"; break; case 5: maandString = "Mei"; break; case 6: maandString = "Juni"; break; case 7: maandString = "Juli"; break; case 8: maandString = "Augustus"; break; case 9: maandString = "September"; break; case 10: maandString = "Oktober"; break; case 11: maandString = "November"; break; case 12: maandString = "December"; break; default: maandString = "Onbekende maand"; break;} System.out.println(maandString);}} Zoals je ziet, staat er achter het statement van een case telkens een break;. Bij een case statement wordt gesprongen naar het bijbehorende label. Alle statements die daar achter staan, worden uitgevoerd. Als er geen breaks stonden, dan zou voor alle getallen tussen 1 en 12 het resultaat zijn dat maandString gelijk wordt gemaakt aan December (ga dat na). De break zorgt ervoor dat na toekenning van de maand uit het switch statement wordt gesprongen.

3.6 De statements “while” en “do while” Giedrius tikt de volgende code in. public class WhileLoop


{ public static void main(String[] args) {

int x= 10; while( x < 20 )

{ System.out.print("value of x : " + x ); x++; .out.print("\n"); } } } Hij slaat het op onder de naam WhileLoop.Java, compileert het en voert het uit. Het resultaat ziet er als volgt uit.

Hierin is gebruikgemaakt van een nieuw loopstatement en van het if then else-statement. Merk nog op dat hier niet gebruik is gemaakt van println maar van print. Deze drukt af wat er tussen de haakjes staat zonder naar de volgende regel te springen. Het statement print(“\n”); zorgt hier voor een newline (nieuwe regel). Opdracht: de syntax voor een do while loop is als volgt. Do { … } while (conditie) Herschrijf bovenstaand programma en gebruik deze loop-structuur.


3.7 Data uitvoer (formatteren uitvoer of zoiets) Opdracht: tik de volgende code in, verklaar wat het doet en test het. Let goed op de case sensitivity! public class TafelVan { public static void main(String[] args) { int basis = Integer.parseInt(args[0]); for(int teller=1; teller<=10; teller++) { String fs = String.format("%2d * %4d = %5d", teller, basis, teller * basis); System.out.println(fs); } } } Tip: maak gebruik van internet om de gebruikte functies op te zoeken. Resultaat van deze code is als volgt.

3.8 Data invoer Tot nu toe hebben we invoer van onze programma’s via de commandline laten lopen. Het is natuurlijk ook mogelijk om vanuit de code data in te voeren. Hier volgt een codevoorbeeld.

import Java.io.Console; public class ReadName{ public static void main(String[] args){ Console c = System.console(); String Naam = c.readLine("Wat is uw naam? "); c.printf("Uw naam is: %s\n", Naam);}}


De code begint met een importstatement. In dit geval is dat nodig. De gebruikte functies zitten namelijk niet in standaard Java, maar moeten vanuit een ander programma, een bibliotheek (library), worden geïmporteerd. Om te beginnen wordt er een variabele c van het type Console aangemaakt voor de in- en uitvoer. Met c.readline(“Wat is uw naam?”); wordt een string ingelezen in de string variabele Naam. Via het statement c.printf("Uw naam is: %s\n", Naam); wordt de ingevoerde naam naar het scherm teruggeschreven. De printf zorgt voor een formatted print van de variabele Naam. In de string (1e argument) geef je aan welke tekst er moet worden afgedrukt en hoe de variabele (2e argument) moet worden weergegeven. In dit geval %s om een string af te drukken.

Opdracht: maak deze code werkend.

Opdracht: zoek op internet alle format types voor printf op.

3.9 Het keyword ‘new’ Bij declaraties in Java wordt voor een variabele een hoeveelheid geheugen gereserveerd. Als je bijvoorbeeld een integer variabele declareert: int var; dan wordt voor de variabele var een hoeveelheid geheugen vrijgehouden waarin een integer variabel kan worden opgeslagen.

Van een integer kun je van tevoren aangeven hoeveel geheugen deze inneemt. Er zijn echter ook declaraties waarvan je van tevoren niet kunt aangeven hoe groot ze zullen worden. Denk hierbij bijvoorbeeld aan tekststrings waarin je een naam opslaat of aan arrays waarvan je niet van tevoren weet hoeveel elementen ze zullen bevatten. De grootte wordt dan ‘dynamisch’ bepaald, dus terwijl het programma actief is.

Het dynamisch declareren van variabelen gebeurt met het keyword new. Bekijk het volgende voorbeeld.

public class ArrayTafelVan { public static void main(String args[])

{ int basis = Integer.parseInt(args[0]); int lengte = Integer.parseInt(args[1]); int[] results = new int[lengte]; for(int teller=0; teller<lengte; teller++)

{ results[teller] = teller*basis; } for(int teller=0; teller<lengte; teller++)

{ String fs = String.format("%2d * %4d = %5d", teller, basis, results[teller]); System.out.println(fs); } } } Dit programma doet hetzelfde als het programma TafelVan dat hiervoor is besproken. Alleen wordt hier eerst een array van integers gevuld die daarna dan wordt afgedrukt. Arrays kunnen in Java dus worden gedeclareerd via het keyword new.


Wel begint de tafel hier bij 0 in plaats van 1 en eindigt bij 9 in plaats van bij 10. Dat is omdat array indexen in Java bij 0 beginnen te nummeren. Je roept dit programma bijvoorbeeld als volgt aan.

Opdracht: test dit programma.


4 Objectgeoriënteerd programmeren Je begint zo langzamerhand nieuwsgierig te worden naar het objectgeoriënteerd programmeren (in het Engels: Object Oriented Programming of OOP) dat aan Java ten grondslag ligt.

Giedrius brengt het als volgt onder woorden.

BASIC, de vorige taal, is een zogenaamde procedurele programmeertaal. Dat wil zeggen dat je werkt met codes (statements) die worden samengevoegd tot procedures.

Bij OOP werk je met objecten. Die objecten bevatten eigenschappen (properties) en methoden (methods). Met behulp van de properties leg je de ‘toestand’ (state) van het object vast. Met de methods leg je acties vast die de toestand van je object kunnen veranderen.

Voorbeeld: stel je voor dat je een computerprogramma wilt maken waarmee je auto’s over je scherm wilt laten rijden. Als je dat met OOP maakt, dan begin je bijvoorbeeld met ‘auto objecten’.

Properties van zo’n auto object zijn dan bijvoorbeeld: positie en snelheid.

Stel je hebt vijf auto’s: Ford1, Ford2, Opel1, Opel2 en Mini1. Elke auto heeft zijn eigen snelheid en positie. Die kun je opvragen of een waarde geven door het object, gevolgd door de property en gescheiden door een punt.

Ford1.snelheid = 120; Ford2.snelheid = 110; Totdat je de snelheid aanpast heeft Ford1 een snelheid van 120 km/h en Ford2 110 km/h.

Een voorbeeld van een method zou kunnen zijn: BepaalPositie(); een method die de positie van een auto bepaalt na een bepaalde tijd, uitgaande van de beginpositie en de snelheid. Je roept zo’n method als volgt aan. Ford1.BepaalPositie(); De berekeningen laten we hier even achterwege. Daarna kun je de positie uitlezen: NewPos = Ford1.positie;

Zoals je ziet, weet elk object steeds van zichzelf wat zijn snelheid en positie is. Op deze manier krijg je overzichtelijke, makkelijk te onderhouden programma’s.

4.1 Objecten definiëren Hoe kom je nu aan de objecten Ford1, Ford2 enzovoort? Met andere woorden: hoe declareer je? Er is immers geen variabele type Auto?

Zo’n variabele type maak je zelf met een zogenaamde classdefinitie.

Laten we beginnen met een eenvoudige class om je auto’s mee te maken. We maken daarin een variabele van het type int aan (speed) en een method (displaySpeed). In de variabele bewaren we van een object zijn snelheid. De method zorgt ervoor dat we de snelheid op het scherm kunnen afdrukken.

Die class definitie ziet er als volgt uit.

class Auto { public int speed; public void displaySpeed()


{ System.out.printf( "Snelheid = %d", speed ); } } Laten we even nauwkeurig naar deze classdefinitie kijken.

De definitie zelf heeft dus de vorm

class Auto { ... }

Binnen de accolades worden de eigenlijke onderdelen (properties en methods) van de class gedefinieerd.

Het eerste is public int speed; hiermee wordt de variabele aangemaakt waarin de snelheid van je auto is opgeslagen. Deze is van het type int (integer). Het keyword public betekent dat je hem kunt aanroepen. De tegenhanger van public is private. Een private variabele is alleen zichtbaar binnen je class. Die is dus echt voor intern gebruik. We zien daar straks voorbeelden van.

Het tweede onderdeel is een method genaamd public void displaySpeed() { ... }.

Deze method zorgt ervoor dat je snelheid wordt afgedrukt op je scherm.

Het return type is void. Dat betekent dat de functie geen waarde teruggeeft als je hem aanroept. De body van deze method bestaat uit één statement: System.out.printf("Snelheid = %d\n", speed);

Een volledig programma om deze class te gebruiken ziet er als volgt uit.

public class AutoTest { public static void main( String args[] ) { Auto Ford1; Auto Ford2;

Ford1 = new Auto(); Ford2 = new Auto();

Ford1.speed = 120; Ford2.speed = 110; Ford1.displaySpeed(); Ford2.displaySpeed(); } } class Auto { public int speed; public void displaySpeed()


{ System.out.printf("Snelheid = %d\n", speed); } } Opdracht: maak hiervan een programma en test het. Je ziet dat er twee objecten (zogenaamde instances) worden aangemaakt, genaamd Ford1 en Ford2. Dat is analoog aan het aanmaken van een integer variabele: int i1;. Alleen heb je nu het type Auto zelf aangemaakt terwijl het type int al bestaat. Ook zie je het keyword new in Ford1 = new Auto(); en Ford2 = new Auto();. Hiermee wordt geheugen aangemaakt voor de twee auto’s. Dat is nodig. Via de declaratie maak je namelijk alleen een verwijzing aan. Een lege huls zonder inhoud.

In de auto willen we nu de totaal afgelegde afstand onthouden. De afgelegde afstand is snelheid x tijd. Dus bijvoorbeeld als je 120 km per uur rijdt gedurende twee uur, dan heb je 240 km afgelegd. We slaan de kilometerstand op en maken een method om de kilometerstand bij te houden. De class ziet er als volgt uit.

class Auto { public int speed; public int TotalDistance; public void updateTotalDistance(int time) { TotalDistance = TotalDistance + speed * time; } public void displaySpeed() { System.out.printf("Snelheid = %d\n", speed); } } Zoals je kunt zien, wordt de totaal afgelegde afstand (TotalDistance) bijgewerkt door er steeds het product van snelheid en tijd (speed * time) bij te tellen. Hij zou als volgt kunnen worden gebruikt.

public class AutoTest2 { public static void main( String args[] ) { Auto Volkswagen = new Auto(); Auto Opel = new Auto(); int ElapsedTime; Volkswagen.TotalDistance = 0; Opel.TotalDistance = 0; //De snelheid van de Volkswagen wordt op 120 gezet en van de Opel op 90 Volkswagen.speed = 120; Opel.speed = 90; //De verlopen tijd is 2 uur.


ElapsedTime = 2; //Volkswagen rijdt dus 2 uur met een snelheid van 120. Legt dus 240 km af in die tijd. Volkswagen.updateTotalDistance(ElapsedTime); //Opel rijdt 2 uur met een snelheid van 90. Legt dus 180 km af. Opel.updateTotalDistance(ElapsedTime); System.out.printf("Kilometerstand Volkswagen na %d uur: %d km\n",

ElapsedTime ,Volkswagen.TotalDistance); System.out.printf("Kilometerstand Opel na %d uur: %d km\n",

ElapsedTime, Opel.TotalDistance); //Nu gaan we nog 3 uur rijden ElapsedTime = 3; //Volkswagen rijdt 3 x 120 = 360 km. Die wordt opgeteld bij de afgelegde afstand. //Totaal dus 240 + 360 = 600 km in 2 + 3 = 5 uur Volkswagen.updateTotalDistance(ElapsedTime); //Opel rijdt 3x 90 = 270 km; totaal 180 + 270 = 450 km in 2 + 5 uur. Opel.updateTotalDistance(ElapsedTime); System.out.printf("Kilometerstand Volkswagen na %d uur: %d km\n",


ElapsedTime, Opel.TotalDistance); //Beide auto’s gaan nu 50 rijden gedurende 3 uur en leggen dus 3 x 50 = 150 km af //Totaal dus voor Volkswagen 600 + 150 = 750 km, Opel 450 + 150 = 600 km

Volkswagen.speed = 50; Opel.speed = 50; ElapsedTime = 3; Volkswagen.updateTotalDistance(ElapsedTime); Opel.updateTotalDistance(ElapsedTime); System.out.printf("Kilometerstand Volkswagen na %d uur: %d km\n",


ElapsedTime, Opel.TotalDistance); } } Dit levert de volgende output.


Opdracht: de gegeven tijden zijn telkens de tussentijden. Om een gemiddelde snelheid te bepalen is een totaal tijd nodig. Voeg deze toe. Voeg ook een functie toe om de verlopen tijd toe te voegen aan de totaal tijd. Opdracht: voeg nu een functie toe die de gemiddelde snelheid berekent. De gemiddelde snelheid is het quotiënt van de totaal afgelegde afstand en de totaal verlopen tijd. Tip: gebruik in plaats van integergetallen floatgetallen. Opdracht: breid de Auto class zodanig uit dat het gemiddelde verbruik van de auto kan worden uitgelezen. Hiervoor moet dan ook de hoeveelheid brandstof worden bijgehouden. Gebruik ook hier floatgetallen.

4.2 Overerving Classes voor verschillende vervoermiddelen verschillen op veel punten, maar hebben vaak ook veel gemeen. Het komt daarom vaak voor dat verschillende classes veel op elkaar lijken Zo zijn auto’s, motorfietsen, vliegtuigen en schepen allemaal vervoermiddelen. Ze verschillen alleen in het aantal wielen (schepen 0, auto’s 4, motorfietsen 2).

Ook hebben sommige vervoermiddelen eigenschappen die voor andere vervoermiddelen niet bestaan. Zo heeft een vliegtuig een vlieghoogte en een schip een diepgang. Auto’s en motoren hebben geen van beide eigenschappen.

Maar ze hebben wel allemaal een snelheid en een gemiddeld brandstofverbruik.

In zo’n geval kun je een overkoepelende class definiëren die de eigenschappen en functies die gemeenschappelijk zijn, in zich heeft. Bijvoorbeeld class Vervoermiddel.

De classes zoals Auto, Schip, Motorfiets en Vliegtuig kunnen daar dan van worden afgeleid waardoor ze alle properties en methods uit de class Vervoermiddel erven. Dit noemen we overerving of inheritance.

Als een class op deze manier erft van een andere class (de parent), dan erft deze de methods en properties van de parent.


Dus als we een class Vervoermiddel definiëren met de property aantalWielen en de method updateTotalDistance (float Time), dan zal elke class die hiervan erft diezelfde property en method bezitten. Dat overerven wordt aangegeven met het keyword extends.

Hier zie je een voorbeeld.

class VervoerMiddel { public int TotalDistance; public int speed; public void updateTotalDistance(int time) { TotalDistance = TotalDistance + speed * time; } } class Auto extends VervoerMiddel { public void displaySpeed() { System.out.printf("Snelheid = %d\n", speed); } } De class Auto overerft van de class VervoerMiddel. Daardoor heeft Auto de beschikking over TotalDistance, speed en updateTotalDistance. De method displaySpeed is lokaal toegevoegd. Verder kan met code zoals in de applicatie AutotTest2 de class Auto precies hetzelfde worden gebruikt. Zodoende geeft de code hierna public class AutoTest3 { public static void main( String args[] ) { Auto Volkswagen = new Auto(); Auto Opel = new Auto(); int ElapsedTime; Volkswagen.TotalDistance = 0; Opel.TotalDistance = 0; Volkswagen.speed = 120; Opel.speed = 90; ElapsedTime = 2; Volkswagen.updateTotalDistance(ElapsedTime); Opel.updateTotalDistance(ElapsedTime); System.out.printf(

"Kilometerstand Volkswagen na %d uur: %d km\n", ElapsedTime ,Volkswagen.TotalDistance);

System.out.printf( "Kilometerstand Opel na %d uur: %d km\n", ElapsedTime, Opel.TotalDistance);


} } het volgende resultaat

Overerving kan ook over meer niveaus gebeuren. Zo kan een Auto worden gebruikt om verschillende merken af te leiden en daarna verschillende typen. VervoerMiddel – Auto – Merk – Type - Uitvoering met bijvoorbeeld als objecten. Merk:- Volkswagen Type: - Golf Uitvoering: - GTI Opdracht: maak hiervoor een classmodel.

4.3 De ArrayList Voor we verder te gaan met de uitwerking van classes en objecten, komt nu de ArrayList aan de orde. Een ArrayList is een verzameling elementen ongeveer zoals een array. Je hoeft niet van tevoren de dimensie op te geven maar kunt er steeds elementen aan toevoegen of eruit verwijderen. Het volgende voorbeeld laat dit zien.

import Java.util.*; class DynArray { public static void main(String args[]) { // Maak een arraylist aan. ArrayList al = new ArrayList(); //Hier is de lijst nog leeg. Size is 0; System.out.println("Lengte (Size) in het begin: " + al.size()); // zet elementen in de arraylist al.add("Aap"); al.add("Noot"); al.add("Mies"); al.add("Zus"); al.add("Jet"); // display de size van de arraylist System.out.println("Lengte (Size) na toevoegen van elementen: " + al.size()); // display de array list zelf PrintList(al); //Toevoegen element op locatie 3 al.add(3, "Wim"); System.out.println("Lengte na toevoegen van 1 nieuw element op positie 3 (4e positie): "


+ al.size()); PrintList(al); // Verwijder element nr 2 (3e element) van de arraylist al.remove(2); System.out.println("Lengte nadat element nr 2 (3e element) is verwijderd: " + al.size()); PrintList(al); al.remove("Zus"); System.out.println("Lengte nadat element ‘Zus’ is verwijderd: " + al.size()); PrintList(al); } //Deze functie drukt de inhoud van de als argument meegegeven lijst af. static void PrintList(ArrayList L){ for(int i = 0; i < L.size(); i++) System.out.println("Element(" + String.valueOf(i) + ")=" + (String)(L.get(i))); } } Hierover valt weer heel wat uit te leggen. Als eerste de bovenste regel (import Java.util.*; ). Deze zorgt ervoor dat het ArrayList-type beschikbaar is binnen je programma. Met (ArrayList al = new ArrayList();) maak je een ArrayList element aan genaamd al. Voor de rest staat in de code comments (vooraf gegaan met //) de werking van het programma. De functie PrintList(ArrayList L){..} krijgt als argument een variabele mee van het type ArrayList. In de functie wordt gekeken naar de lengte van de lijst en in een loop wordt de inhoud afgedrukt. De functie String.valueOf(i) zet een variabele van het type int om in een string. Als je dit programma uitvoert, dan krijg je het volgende resultaat.


Opdracht: tik dit programma in, compileer het en bekijk het resultaat. Bestudeer de werking. Opdracht: maak een dynamische array van objecten van het type Auto aan. Maak ook hiervoor een PrintList(Auto a)functie.

4.4 Access modifiers: public en private De class en property/method namen in bovenstaande voorbeelden worden soms voorafgegaan door de woorden public en private. Dit zijn zogenaamde access modifiers. Deze beschrijven hoe de variabelen of methods waar ze voor staan, toegankelijk zijn. Als een method wordt voorafgegaan door de modifier public, dan is die method van buiten bereikbaar. Als private is deze method niet van buiten bereikbaar.

Bekijk het volgende voorbeeld.

class Auto { private int Speed; public void SetSpeed(int s) // zet de waarde van Speed { Speed = s; } public int GetSpeed() // return de waarde van Speed { Return s; } } Als je nu een object maakt van deze class, bijvoorbeeld als volgt, Auto Ford = new Auto(); dan is Speed niet toegankelijk omdat deze als private is gedeclareerd. De functies SetSpeed en GetSpeed zijn wel toegankelijk en worden in dit geval gebruikt om Speed te manipuleren.

Dus Ford.Speed is niet toegestaan, maar Ford.SetSpeed(100) en Ford.GetSpeed() wel.

Het gebruik van zo’n functie wordt vaak toegepast. Je kunt daarmee interne variabelen als het ware afschermen voor veranderingen van buiten af. Door die veranderingen via functies te laten lopen kun je bijvoorbeeld tests inbouwen voordat je de variabele verandert. Zo zou je kunnen eisen dat Speed een positieve waarde moet hebben. Als geen positieve waarde wordt meegegeven aan de functie SetSpeed, dan wordt de waarde niet ingevuld.

class AutoTest4 { public static void main(String args[]) { Auto Ford = new Auto(); Ford.SetSpeed(100); System.out.printf("%s\n", Ford.GetSpeed()); Ford.SetSpeed(-50);


System.out.printf("%s\n", Ford.GetSpeed()); Ford.SetSpeed(50); System.out.printf("%s\n", Ford.GetSpeed()); } } class Auto { private int Speed; public void SetSpeed(int s) // zet de waarde van Speed ... { if(s >= 0) Speed = s; // ... alleen als die waarde positief is else System.out.printf("%s is negatief\n", s); } public int GetSpeed() // return de waarde van Speed { return Speed; } } Zoals je ziet, wordt in SetSpeed eerst getest of de meegegeven waarde groter is dan 0. Het resultaat is als volgt.

4.5 Constructors Een belangrijk onderdeel van classes zijn de constructors. Constructors worden gebruikt om bepaalde properties een startwaarde te geven of om variabelen te declareren. Bij het aanmaken van een object op basis van een class kan een constructor worden aangeroepen. Welke er wordt aangeroepen, hangt af van de aanroep.

Een constructor roep je dan aan achter een new in plaats van een gewone declaratie.

Auto Opel; //Declaratie. Hier wordt het type van Opel vastgelegd. Het is een object van type Auto Opel = new Auto(); //Hier wordt geheugen gealloceerd voor Opel. Beide stappen zijn noodzakelijk. De new Auto(); noemen we de default constructor. Stel nu dat je bij het aanmaken de snelheid van een Auto op 50 wilt zetten. Je kunt dat dan in de standaardconstructor zetten.

class Auto { private int Speed; public Auto() //Default constructor {


Speed = 50; } public void SetSpeed(int s) // zet de waarde van Speed ... { if(s >= 0) Speed = s; // ... alleen als die waarde positief is .... Je ziet in schuinschrift een standaardconstructor (geen argumenten) die de snelheid op 50 zet. Met een tweede constructor kun je de beginsnelheid op een bepaalde, zelf te kiezen, waarde zetten. class Auto { private int Speed; public Auto() //Default constructor { Speed = 50; //De snelheid wordt standaard op 50 gezet } public Auto(int s) //Constructor voor Speed { Speed = s; } public void SetSpeed(int s) // zet de waarde van Speed ... { if(s >= 0) Speed = s; // ... alleen als die waarde positief is …. Schuingedrukt zie je hier een constructor die de waarde van Speed, de als s meegegeven waarde geeft.

Hier volgt de code van de constructors.

class AutoTest4 { public static void main(String args[]) { Auto Ford = new Auto(); //Aanroep standaard (default) constructor System.out.printf("%s\n", Ford.GetSpeed()); Auto Opel = new Auto(75); //Aanroep tweede constructor. System.out.printf("%s\n", Opel.GetSpeed()); } } class Auto { private int Speed; public Auto() //Default constructor { Speed = 50; } public Auto(int s) //Constructor voor Speed {


Speed = s; } public void SetSpeed(int s) // zet de waarde van Speed ... { if(s >= 0) Speed = s; // ... alleen als die waarde positief is else System.out.printf("%s is negatief\n", s); } public int GetSpeed() // return de waarde van Speed { return Speed; } } Dit is het resultaat.

Opdracht: breid de Auto class uit met een stringveld waarin het merk kan worden opgeslagen. Daarnaast moet een constructor toegevoegd worden, waaraan als argument het merk kan worden meegegeven: Auto a = new Auto(“Porsche”); Je moet hiervoor een property Merk toevoegen van het type String.


4.6 Casting Als voorbeeld gaan we nu de ArrayList combineren met de constructors om een lijst met auto’s te maken en die dan af te drukken. Bestudeer de volgende code.

import Java.util.*; class AutoTest5 { public static void main(String args[]) { ArrayList autos = new ArrayList(); autos.add(new Auto("Ford")); autos.add(new Auto("Opel")); autos.add(new Auto("Volkswagen")); autos.add(new Auto("Mini")); autos.add(new Auto("Fiat")); for(int i = 0; i < autos.size(); i++) ((Auto)autos.get(i)).Print(); } } class Auto { private String Merk; public void Print() { System.out.printf("%s\n",Merk); } public Auto(String m) { Merk = m; } } Boven in wordt eerst een ArrayList aangemaakt. Die wordt vervolgens gevuld met nieuwe objecten van het type Auto. Let op het gebruik van de constructor.

In een loop onder aan wordt voor elk element van de ArrayList de method Print() aangeroepen. Bekijk daarvoor het statement ((Auto)autos.get(i)).Print(); nauwkeurig.

Via autos.get(i) is heb je toegang tot een element met rangnummer i. Normaal gesproken zou je dus via dit element de method Print() als volgt kunnen aanroepen. autos.get(i).Print(); Maar als je dat probeert, geeft de compiler een foutmelding. Deze herkent namelijk Print() niet als een method die bij een element van een ArrayList hoort. Je moet hier aangeven dat dat element van het type Auto is. Dat doe je via zogenaamde casting. Je zet het type, in dit geval Auto, tussen haakjes voor de variabele. Dus met (Auto)autos.get(i) geef je aan dat dat element van het type Auto is.

Het hele statement moet vervolgens tussen haken worden geplaatst alvorens voor de compiler duidelijk is dat dat bij Print() hoort.

De uitvoer van het programma ziet er als volgt uit.


Let op de compiler warning. Via een warning maakt de compiler je attent op een mogelijk probleem. In dit geval het feit dat je een variabele omzet naar een ander type.

4.7 Generics Een andere manier om dit probleem op te lossen is met behulp van generics. Hiermee kun je tussen <> aangeven van welk type de structuur (in dit geval de ArrayList) moet zijn. Zie hiervoor het volgende voorbeeld.

import Java.util.*; class AutoTest6 { public static void main(String args[]) { ArrayList<Auto> autos = new ArrayList<Auto>(); autos.add(new Auto("Ford")); autos.add(new Auto("Opel")); autos.add(new Auto("Volkswagen")); autos.add(new Auto("Mini")); autos.add(new Auto("Fiat")); for(int i = 0; i < autos.size(); i++) autos.get(i).Print(); } } class Auto { private String Merk; public void Print() { System.out.printf("%s\n",Merk); } public Auto(String m) { Merk = m; } } Aan de ArrayList is toegevoegd: <Auto>. Dit geeft aan de compiler aan, van welk type de elementen van ArrayList autos zijn.


4.8 Static Je bent al verschillende keren het begrip static tegengekomen. Static wordt onder andere gebruikt om functies (methods) te kunnen gebruiken zonder dat een instance van een class hoeft te worden gemaakt.

Static wordt vaak gebruikt om bibliotheken te maken met functies, bijvoorbeeld in- en uitvoerfuncties.

Een voorbeeld is deze zelfgemaakte class Maths waarin een verzameling wiskundige functies kunnen worden opgenomen. Bijvoorbeeld een functie AddInts die twee integergetallen optelt. Zoals je ziet, is deze functie van het type public static.

class StaticTest { public static void main(String args[]) { int comp1 = 3; int comp2 = 6; System.out.printf("%d\n", Maths.AddInts(comp1 , comp2)); } } class Maths { public static int AddInts(int i1, int i2) { return i1 + i2; } } Opdracht: creëer een class met daarin de volgende twee static-hulpfuncties.

1 Een functie int Som(int first, int last) die de som van alle getallen retourneert tussen first en last. Dus bijvoorbeeld Som(4,8) resulteert in: 4+5+6+7+8 =30.

2 Een functie float Gemiddelde(float x, float y) die de gemiddelde waarde van twee getallen retourneert. Dus Gemiddelde(3.5, 6.4) wordt (3.5 + 6.4)/2 =4.95.


5 Aan de slag met bonnen in Java

5.1 Het bonnenprogramma in OOP Je gaat nu aan de slag om het in BASIC geschreven bonnenprogramma om te zetten in een Object Oriented Programmingapplicatie.

Om te beginnen wil je een model maken waarin de verschillende rekeningen worden bijgehouden. Uit de BASIC-hoofdstukken weet je dat je per kegelbaan moet bijhouden wat er aan huur, consumpties enzovoort, is gebruikt. Met de kennis die je nu hebt, kun je hier een datamodel van maken. Je gaat namelijk werken met arraylists en classes.

We gaan uit van soorten objecten waarvoor we classes gaan maken. We maken de classes Reservering en Consumptie. In het hoofdprogramma wordt een lijst met reserveringen bijgehouden en in elke reservering een lijst van gebruikte consumpties.

De classes die we nodig hebben zien er in concept als volgt uit.

class Reservering { private int BaanNummer; private int jaar; private int maand; private int dag; private int uur; private int AantalUren; private ArrayList<Consumptie> consumpties; } class Consumptie { private String Naam; private float Prijs; public Consumptie(String naam, float prijs) { Prijs = prijs; Naam = naam; } }


Bekijk nu de volgende code waar deze classes volledig worden uitgewerkt in een programma. import Java.util.*; class Bonnen1 { public static void main(String args[]) { //Creeer een lijst met reserveringen ArrayList<Reservering> reserveringen = new ArrayList<Reservering>(); //Creeer een reservering reserveringen.add(new Reservering("Jan Klaassen" ,3,2012,2,3,12,2)); //Voeg consumpties toe aan deze reservering reserveringen.get(0).AddConsumptie("Coca cola", 1.50f); reserveringen.get(0).AddConsumptie("Witte wijn", 2.25f); reserveringen.get(0).AddConsumptie("Biefstuk met frites", 8.95f); reserveringen.get(0).AddConsumptie("Kip met frites", 7.50f); reserveringen.get(0).AddConsumptie("Coca cola", 1.50f); reserveringen.get(0).AddConsumptie("witte wijn", 2.25f); reserveringen.get(0).AddConsumptie("Cappuccino", 1.95f); reserveringen.get(0).AddConsumptie("Cappuccino", 1.95f); // Maak een overzicht for(int i = 0; i < reserveringen.size(); i++)

{ reserveringen.get(i).Print();

} } } class Reservering { private String Naam; private int BaanNummer; private int Jaar; private int Maand; private int Dag; private int Uur; private int AantalUren; private ArrayList<Consumptie> consumpties; public void AddConsumptie(String naam, float prijs) //Voeg consumptie toe { consumpties.add(new Consumptie(naam, prijs)); } //Constructor public Reservering

(String naam, int baannummer, int jaar, int maand, int dag, int uur, int aantalUren) { Naam = naam; BaanNummer = baannummer; Jaar = jaar; Maand = maand; Dag = dag; Uur = uur; AantalUren = aantalUren;


consumpties = new ArrayList<Consumptie>(); } private float BerekenTotaal() // Bereken het totaal van de consumpties { float totaal = 0; for(int i = 0; i < consumpties.size(); i++) totaal += consumpties.get(i).GetPrijs(); return totaal; } public void Print() { System.out.printf

("Baan %2d Naam: %s Datum %2d/%2d/%2d Tijd %2d uur Lengte %2d uur\n", BaanNummer, Naam, Jaar, Maand, Dag, Uur, Lengte);

for(int i = 0; i < consumpties.size(); i++) //Print alle consumpties {

consumpties.get(i).Print(); } System.out.printf("Totaal %8.2f\n", BerekenTotaal()); //Print het totaal } } class Consumptie { private String Naam; private float Prijs; public float GetPrijs() { return Prijs; } public Consumptie(String naam, float prijs) { Prijs = prijs; Naam = naam; } public void Print() { System.out.printf("Naam: %s Prijs: %8.2f\n", Naam, Prijs); } } Opdracht: bestudeer deze code, voer het in en test het. Let op de volgende twee nieuwe taalelementen. In de format string zie je %8.2f. Dat betekent de weergave van een float variabele op 8 posities met 2 plaatsen achter de komma. In de functie BerekenTotaal zie je +=. A+=X dit betekent tel X bij A; dus hetzelfde als A=A+X.

Wat je aan dit voorbeeld ziet, is dat het zeer overzichtelijk is hoe je de consumpties bij een baanreservering bijhoudt. Elke reservering weet als het ware van zichzelf welke consumpties er bij hem horen.

Wat nu is gemaakt, vormt de basis om het bonnenprogramma om te zetten naar Java. De classes moeten worden uitgebreid met functionaliteit.


Opdracht: er moet een uitbreiding komen van BerekenTotaal. Bij het totaal moet nog de baanhuur worden opgeteld. Bedenk hiervoor een oplossing. (aantalUren * huurPerUur)

De class Consumptie is nog uitgebreid. Onder andere met een zogenaamde enum. Een enum wordt gebruikt om verschillende opties op te slaan op een symbolische manier. Je kunt altijd hetzelfde bereiken door opties op te slaan in integer getallen. Door het gebruiken van enums is het echter inzichtelijker wat die getallen betekenen.

Zo kun je voor de dagen van een week getallen gebruiken: 1, 2, 3, 4, 5, 6, 7. Je kunt de dagen van een week echter ook aangeven via een enum definitie.

public enum WeekDag {zondag, maandag, dinsdag, woensdag, donderdag, vrijdag, zaterdag}

In een switch statement kun je dit dan als volgt gebruiken.

WeekDag dag = dinsdag; switch (dag) { case zondag: Doe zondag acties…. break; case maandag: Doe maandag acties…. break; case dinsdag: Doe dinsdag acties…. break; case woensdag: Doe woensdag acties…. break; case donderdag: Doe donderdag acties…. break; case vrijdag: Doe vrijdag acties…. break; case zaterdag: Doe zaterdag acties…. break; default: doe niets…. Dit maakt code overzichtelijker dan bij het gebruik van getallen.

int dag = 3; switch (dag) { case 1: Doe zondag acties…. break; case 2: Doe maandag acties…. break; case 3: Doe dinsdag acties…. break; case 4: Doe woensdag acties…. break; case 5: Doe donderdag acties…. break; case 6: Doe vrijdag acties…. break; case 7: Doe zaterdag acties…. break; default: doe niets….


Op dezelfde manier als hiervoor bij de weekdagen kun je met een enum verschillende consumptietypen definiëren.

Er is ook een nieuwe constructor gemaakt. Hierin wordt een kopie gemaakt van een variabele van het type constructor. Dit wordt gebruikt bij het invoegen van een consumptie uit een lijst met consumpties.

class Consumptie { public enum ConsumptieType { Drank, Voorgerecht, Hoofdgerecht, Dessert; } private ConsumptieType Type; private String Naam; private float Prijs; public float GetPrijs() { return Prijs; } public Consumptie(String naam, float prijs, Consumptie.ConsumptieType type) { Prijs = prijs; Naam = naam; Type = type; } public Consumptie(Consumptie consumptie) { Prijs = consumptie.Prijs; Naam = consumptie.Naam; Type = consumptie.Type; } public void Print() { System.out.printf("%s : %8.2f\n", Naam, Prijs); } }

Ook de class Reservering is aangepast. Zo is er bij het berekenen van het totaal de baanhuur toegevoegd. De functie AddConsumptie is aangepast zodat hij als argument een Consumptie meekrijgt.

class Reservering { private String Naam; private int BaanNummer; private int Jaar; private int Maand; private int Dag; private int Uur; private int Lengte; private float Huurprijs = 8.25f;


private ArrayList<Consumptie> consumpties; public void AddConsumptie(Consumptie c) { consumpties.add(c); } public Reservering(String naam, int baannummer, int jaar, int maand, int dag, int uur, int lengte) { Naam = naam; BaanNummer = baannummer; Jaar = jaar; Maand = maand; Dag = dag; Uur = uur; Lengte = lengte; consumpties = new ArrayList<Consumptie>(); } private float BerekenTotaal() { float totaal = 0; totaal += Lengte * Huurprijs; for(int i = 0; i < consumpties.size(); i++) totaal += consumpties.get(i).GetPrijs(); return totaal; } public void Print() { System.out.printf("Baan %2d Naam: %s Datum %2d/%2d/%2d Tijd %2d uur Lengte %2d uur\n", BaanNummer, Naam, Jaar, Maand, Dag, Uur, Lengte); System.out.printf("Baanhuur = %2d * %4.2f = %4.2f\n", Lengte, Huurprijs, Lengte * Huurprijs); for(int i = 0; i < consumpties.size(); i++) consumpties.get(i).Print(); System.out.printf("Totaal %8.2f\n", BerekenTotaal()); } } Een voorbeeld van het gebruik van deze classes is als volgt. import Java.util.*; class Bonnen2 { public static void main(String args[]) { //Declaratie van de lijst met consumpties ArrayList<Consumptie> consumpties = new ArrayList<Consumptie>(); //Hier wordt de lijst met consumpties gevuld. consumpties.add(

new Consumptie("Bier", 1.50f, Consumptie.ConsumptieType.Drank)); consumpties.add(

new Consumptie("wijn", 2.25f, Consumptie.ConsumptieType.Drank)); consumpties.add(


new Consumptie("Cappuccino", 1.95f, Consumptie.ConsumptieType.Drank));

consumpties.add( new Consumptie("Kippensoep", 2.95f, Consumptie.ConsumptieType.Voorgerecht));

consumpties.add( new Consumptie("Groene salade", 2.95f, Consumptie.ConsumptieType.Voorgerecht));

consumpties.add( new Consumptie("Biefstuk met frites", 8.95f, Consumptie.ConsumptieType.Hoofdgerecht));

consumpties.add( new Consumptie("Kip met frites", 7.50f, Consumptie.ConsumptieType.Hoofdgerecht));

consumpties.add( new Consumptie("Dame Blanche", 4.95f, Consumptie.ConsumptieType.Dessert));

consumpties.add( new Consumptie("Sorbet ijs", 4.50f, Consumptie.ConsumptieType.Dessert));

ArrayList<Reservering> reserveringen = new ArrayList<Reservering>(); reserveringen.add(new Reservering("Jan Klaassen" ,3,2012,2,3,12,2)); //Hier worden aan de eerste reservering (nr 0) allerlei //consumpties uit de lijst toegevoegd reserveringen.get(0).AddConsumptie(consumpties.get(0)); reserveringen.get(0).AddConsumptie(consumpties.get(1)); reserveringen.get(0).AddConsumptie(consumpties.get(0)); reserveringen.get(0).AddConsumptie(consumpties.get(1)); reserveringen.get(0).AddConsumptie(consumpties.get(3)); reserveringen.get(0).AddConsumptie(consumpties.get(4)); reserveringen.get(0).AddConsumptie(consumpties.get(5)); reserveringen.get(0).AddConsumptie(consumpties.get(6)); reserveringen.get(0).AddConsumptie(consumpties.get(0)); reserveringen.get(0).AddConsumptie(consumpties.get(1)); reserveringen.get(0).AddConsumptie(consumpties.get(7)); reserveringen.get(0).AddConsumptie(consumpties.get(8)); reserveringen.get(0).AddConsumptie(consumpties.get(2)); reserveringen.get(0).AddConsumptie(consumpties.get(2)); //Hier wordt de reservering afgedrukt . reserveringen.get(0).Print(); } }

5.2 Een betere editor Zo langzamerhand begin je de beperkingen van het kladblokprogramma erg te merken. Giedrius adviseert daarom op zoek te gaan naar een betere texteditor. Hij adviseert Scite. Dat is een gratis editor die via internet kan worden gedownload. Vanaf nu werk je dus met Scite waardoor je meer functionaliteit hebt die met Java te maken heeft. Zo herkent Scite zelf dat de gebruikte taal Java is en


formatteert de programmatekst op de juiste manier. Ook kun je regelnummers tonen waardoor het makkelijker is om fouten te vinden in je ingetikte code.

Opdracht: gebruik vanaf nu Scite als texteditor voor je Java-programma’s

5.3 De gebruikersinterface De gebruikersinterface is op dezelfde manier ontwikkeld zoals in de BASIC-versie. Bekijk de volgende code maar om dat te ontdekken.

import Java.io.Console; import Java.util.*; public class OutputTest { public static void main( String args[] ) { int response = 0; //Hierin wordt de door de gebruiker ingetikt respons opgeslagen int Baannummer = 0; //Hierin het baannummer ArrayList<menu> MenuList; //Opslag van de lijst met menu-items mainMenu MainMenu; MenuList = FillMenuList(); MainMenu =FillMainMenuList(); cls(); while ((Baannummer = InputInteger("BaanNummer (0 = exit)>")) != 0) { int CurrentItem = 0;


int CurrentMenuItem = 0; MainMenu.Print(); while((CurrentItem = InputInteger(">")) < (MainMenu.Items.size() - 1)) { cls(); MenuList.get(CurrentItem).Print(); CurrentMenuItem = InputInteger(">"); cls(); MainMenu.Print(); } } } private static mainMenu FillMainMenuList() { mainMenu result = new mainMenu(); result.Items.add(new mainMenuItem("Bar")); result.Items.add(new mainMenuItem("Voorgerecht")); result.Items.add(new mainMenuItem("Hoofdgerecht")); result.Items.add(new mainMenuItem("Dessert")); result.Items.add(new mainMenuItem("Terug")); return result; } private static ArrayList<menu> FillMenuList() { ArrayList<menu> result = new ArrayList<menu>(); menu current; current = new menu("Bar"); current.Items.add(new menuItem("Bier",1.75f)); current.Items.add(new menuItem("Wijn",2.25f)); current.Items.add(new menuItem("Gedistilleerd",2.50f)); current.Items.add(new menuItem("Fris",1.25f)); result.add(current); current = new menu("Voorgerecht"); current.Items.add(new menuItem("Kippensoep",2.75f)); current.Items.add(new menuItem("Tomatensoep",2.75f)); current.Items.add(new menuItem("Garnalencocktail",3.50f)); current.Items.add(new menuItem("Groene salade",1.75f)); result.add(current); current = new menu("Hoofdgerecht"); current.Items.add(new menuItem("Halve kip met frites",8.75f)); current.Items.add(new menuItem("Biefstuk met gebakken aardappels",10.50f)); current.Items.add(new menuItem("Kabeljauw met aardappelpuree",9.25f)); current.Items.add(new menuItem("Vegetarische schotel",8.50f)); result.add(current); current = new menu("Dessert"); current.Items.add(new menuItem("Pêche melba",3.75f)); current.Items.add(new menuItem("Dame blanche",3.75f)); current.Items.add(new menuItem("Fruitsalade",4.25f)); result.add(current); return result; } private static int InputInteger(String text)


{ boolean Forever = true; Console c = System.console(); while(Forever) // keep bugging until an integer is typed in. { String input = ""; int response = -1; input = c.readLine(text); if(isInteger(input)) { return Integer.parseInt(input); } else { System.out.printf("Voer een geheel getal in: "); } } return 0; } private static void cls() { for(int i = 0; i < 25; i++) System.out.printf("\n"); } public static boolean isNumeric(String str) { return str.matches("-?\\d+(.\\d+)?"); } public static boolean isInteger(String str) { return str.matches("-?\\d+?"); } } class mainMenu { public ArrayList<mainMenuItem> Items; public mainMenu() { Items = new ArrayList<mainMenuItem>(); } public void Print() { for(int i=0; i<Items.size(); i++) { Items.get(i).Print(i); } } } class mainMenuItem { private String Naam; public mainMenuItem(String naam) {


Naam = naam; } public void Print(int i) { System.out.printf("%d - %s\n",i , Naam); } } class menu { public ArrayList<menuItem> Items; public String Type; public menu(String type) { Type = type; Items = new ArrayList<menuItem>(); } public void Print() { for(int i=0; i<Items.size(); i++) { Items.get(i).Print(i); } System.out.printf("%d - Terug\n", Items.size() ); } } class menuItem { private String Naam; private float Prijs; public menuItem(String naam, float prijs) { Naam = naam; Prijs = prijs; } public void Print(int i) { System.out.printf("%d - %s %4.2f\n", i, Naam, Prijs); } } Zoals je kunt zien, is er een class gedefinieerd voor het vastleggen van het consumptiemenu namelijk menu. Hierin zit een lijst van elementen van het type menuItem (= menu-item) waarin dan weer de afzonderlijke gerechten en drankjes zitten. Ook het hoofdmenu is op deze manier opgeslagen in mainMenu.


Opdracht: voer dit programma in en test het. Ga na hoe het werkt.

Opdracht: er is een aantal hulpfuncties gedefinieerd, namelijk cls, IsNumeric en IsInteger. Ga na hoe deze precies werken.

Bestudeer: while ((Baannummer = InputInteger("BaanNummer (0 = exit)>")) != 0). Je ziet dat het volgende gebeurt. In het eerste deel binnen de while (Baannummer = InputInteger("BaanNummer (0 = exit)>") krijgt Baannummer een waarde. Het resultaat hiervan, de waarde die Baannummer heeft gekregen, wordt vergeleken met 0. Dus zolang Baannummer ongelijk is aan 0, blijft deze while loop doorlopen. Omdat Baannummer hier een waarde krijgt, kan deze waarde binnen de loop gebruikt worden. Opdracht: waar zie je deze constructie nog meer?

Opdracht: breid het programma uit met enkele menu-items.

Opdracht: combineer deze gebruikersinterface met het deel over reserveringen om een volledig programma te krijgen, waarmee per baan reserveringen en consumpties kunnen worden bijgehouden.


5.4 Samenvatting In dit deel van je stage heb je kennis kunnen maken met Java, een object georiënteerde programmeertaal. Deze kennismaking is heel oppervlakkig: Java is een veelomvattende taal, waarvoor veel tijd nodig is om deze goed te leren.

Wel heb je kunnen zien, dat het programma in Java overzichtelijker is dan hetzelfde programma in BASIC. Het is ook beter te onderhouden en eenvoudiger uit te breiden.


6 Aan de slag met SQL

Om diverse redenen is het noodzakelijk dat de bestelgegevens uit het bonnenprogramma vast worden opgeslagen op de computer, zodat ze later kunnen worden opgeroepen. Dan kunnen bijvoorbeeld de gegevens worden uitgedraaid om naar de boekhouding te worden gezonden. Daarnaast is er behoefte aan allerlei andere verwerkingen van de consumptie-informatie. Zo zou men graag willen weten in welke producten de meeste omzet wordt gemaakt of op welke tijd het het drukst is in de keuken.

De data uit het bonnenprogramma gaan we opslaan in een database. We gaan volgen wat er precies met die database gebeurt en wat we met die data allemaal kunnen. Dat doen we door eerst de wisselwerking te bekijken tussen een klein bestelprogramma genaamd DBBestel en de bijbehorende database.

Om informatie uit de database te halen maken we gebruik van het programma SQLInterpreter. Hierin tikken we SQL-Commando’s. SQL staat voor Structured Query Language. Dit is een taal speciaal gemaakt om informatie uit databases te halen.

De kern van onze database vormen de tabellen. Hierin worden de verschillende bestelonderdelen opgeslagen. De tabel die we als eerste gaan bekijken heet BestelRegel.

Opdracht: bekijk hoe het programma DBBestel werkt. Open het programma en maak enkele bestellingen; bekijk ze via de optie rekeningoverzicht.

De bestellingen worden opgeslagen in een databasetabel genaamd BestelRegel. We gaan nu SQL intikken in SQLInterpreter. Open SQLInterpreter en tik in het query window het volgende in.

DELETE BestelRegel


Klik nu op de knop Execute of toets in Alt+E. Met dit commando wordt de tabel BestelRegel leeggemaakt. Eerder ingevoerde bestellingen worden hierdoor verwijderd.

Tik nu het volgende SQL-commando in.

select * from bestelregel en klik weer op Execute (merk hierbij op dat het blijkbaar niet uitmaakt of je hoofdletters of kleine letters gebruikt)


Zoals je kunt zien, is er geen resultaat. De tabel is leeg.

Voer nu in DBBestel een bestelling in voor baan drie. De eerste bestelling bestaat uit het volgende.

1 witte wijn 1 rode wijn 2 bier


Tik nogmaals select * from bestelregel in en bekijk het resultaat.

Zoals je ziet, is er nu een viertal rijen te zien in het Resultvenster. Je ziet in het Resultvenster rijen en kolommen. De kolommen zijn resp. BaanNummer, MenuItem, Prijs, Afgerekend en Datum. De asterisk (*) in select * from bestelregel geeft aan dat alle kolommen moeten worden getoond. Ook alle rijen worden getoond. Er staan nog maar vier items in de database, de bestelling voor baan drie die je net hebt ingevoerd. Je ziet in de kolom BaanNummer nummer 3 staan. In MenuItem staat de naam van het bestelde item. Verder in kolom Prijs de prijs waarvoor het item is ingeboekt, in kolom Afgerekend wordt weergegeven of het item als is afgerekend en tot slot in de kolom Datum op welke datum en tijd het item is ingevoerd. Opdracht: controleer de waarde van alle kolommen (velden) om te zien of ze overeenkomen met wat je hebt ingevoerd.

Behalve een * kun je ook afzonderlijke veldnamen ingeven. Als je bijvoorbeeld alleen de menu-items en de prijzen wilt zien dan kun je het volgende intikken.

SELECT MenuItem, Prijs FROM BestelRegel


6.1 SQL-filters Nu de data in de database wordt opgeslagen, hebben we ook mogelijkheden om allerlei overzichten te maken. Maar daarom is het wel belangrijk dat je wat meer van SQL weet. We beginnen met het filteren van informatie.

Om daarmee te oefenen gaan we de database vullen met informatie. Het is de omzet van de maand november 2011. Om te importeren kun je in SQLInterpreter intikken: fill en dan op Execute klikken.

Om te controleren of de database inderdaad is geladen, kijken we even hoeveel regels er nu in de database zitten.


Bij scrollen naar de onderkant en daar zien we dat er nu 6413 regels in de database zitten.

Om te beginnen wordt er een filter ingevoerd om alle bestelling voor BaanNummer 2 te bekijken. Een filter wordt beschreven achter een zogenaamde WHERE clause. In dit geval gebeurt dit als volgt.

SELECT * FROM BestelRegel WHERE BaanNummer = 2 Opdracht: voer dit uit en controleer of er totaal 1645 regels worden getoond. Bekijk ook de inhoud van de regels en controleer dat het alleen regels van BaanNummer 2 zijn.

Een van de kolommen heet Afgerekend. Deze heeft een alfanumerieke waarde, een string. In SQL wordt een string aangegeven door de waarde tussen single quotes (‘) te zetten. Voorbeelden:


‘Dit is een string’; een string met 17 karakters. Spaties worden ook als karakter geteld. ‘1234’; een string van 4 cijfers. Niet hetzelfde als een getal! ‘j’; een string met 1 karakter: j Als dus bijvoorbeeld een filter moet worden gemaakt van alle nog niet afgerekende menu-items voor baan 2, dan kan dat als volgt. SELECT * FROM BestelRegel WHERE BaanNummer = 2 AND Afgerekend = ‘n’

Het keyword AND wordt gebruikt om aan te geven dat aan beide voorwaarden moet zijn voldaan.

Opdracht: voer dit uit en controleer of hier tien regels worden weergegeven. Bekijk de inhoud van deze regels. Wanneer zijn ze precies ingevoerd?

Wil je alleen het aantal gegevens tellen, bijvoorbeeld van alle afgerekende items, dan kun je dat als volgt doen.

SELECT COUNT(*) FROM BestelRegel WHERE Afgerekend=‘j’

COUNT(..) is een functie. In dit geval een die een aantal rijen telt. Je had ook een kolomnaam in kunnen vullen, zoals COUNT(BaanNummer).

De kolom heeft nu geen naam. Je kunt een kolom zelf als volgt een naam geven.

SELECT COUNT(*) AS ‘Aantal’ FROM BestelRegel WHERE Afgerekend=‘j’

Er bestaan meer functies. Zo zou je ook de totale omzet kunnen uitrekenen van alle rijen in het systeem. Dat doe je als volgt.

SELECT SUM(Prijs) AS ‘Totale omzet’ FROM BestelRegel

De functie SUM(..) telt alle velden Prijs op.

Opdracht: voer dit uit en controleer dat de totale som van alle Prijs velden uitkomt op 28201.75.

Het combineren van filters met functies kan al veel informatie opleveren.

Opdracht: wat levert het volgende statement op?


SELECT SUM(Prijs) AS Omzet FROM BestelRegel WHERE MenuItem = ‘Kippensoep’ (Merk op dat er geen singlequotes om de naam staan. Dat hoeft niet als het als een woord wordt opgegeven.) En wat levert dit op? SELECT SUM(Prijs) AS Omzet, COUNT(Prijs) as Aantal, SUM(Prijs)/COUNT(Prijs) as GemiddeldePrijs FROM BestelRegel WHERE MenuItem = ‘Tomatensoep’ Klopt de uitkomst? En dit?

SELECT SUM(Prijs) AS Omzet, COUNT(Prijs) as Aantal, SUM(Prijs)/COUNT(Prijs) as GemiddeldePrijs FROM BestelRegel WHERE MenuItem = ‘Kippensoep’ OR MenuItem = ‘Tomatensoep’ OR

MenuItem = ‘Garnalencocktail’ OR MenuItem = ‘Carpaccio’

6.2 Datum- en tijdfuncties Een belangrijke categorie functies is die van de functies met betrekking tot datum en tijd. Deze kunnen worden gebruikt om te filteren en om informatie weer te geven.

De eenvoudigste functies voor datum zijn de twee volgende functies.

-YEAR(..); geeft het jaar van een datum-tijdveld. -MONTH(..); idem maar dan de maand. -DAY(..); idem maar dan de dag. Voorbeeld SELECT YEAR(Datum) as jaar, MONTH(Datum) as maand, DAY(Datum) as dag FROM BestelRegel

Dit maakt een lijst van jaar, maand en dag van elke rij. Het is heel eenvoudig om hiervan alle unieke combinaties weer te geven met behulp van het keyword DISTINCT:

SELECT DISTINCT YEAR(Datum) as jaar, MONTH(Datum) as maand, DAY(Datum) as dag FROM BestelRegel

Je ziet nu een lijst van unieke data die in het systeem aanwezig zijn. Maar de elementen zijn niet gesorteerd. Sorteren kun je doen met behulp van het keyword ORDER BY.

SELECT DISTINCT YEAR(Datum) as jaar, MONTH(Datum) as maand, DAY(Datum) as dag FROM BestelRegel ORDER BY YEAR(Datum), MONTH(Datum), DAY(Datum) Datumfuncties kunnen uiteraard ook in filters worden gebruikt. Een voorbeeld:

SELECT COUNT(MenuItem) Aantal FROM BestelRegel WHERE YEAR(Datum) = 2011 AND MONTH(Datum) = 11 AND DAY(Datum) = 15 AND


MenuItem = ‘Carpaccio’ Opdracht: tik dit SQL-statement in en ga na dat er op 11 november 2011 4 Carpaccio’s zijn verkocht. SELECT COUNT(MenuItem) Aantal FROM BestelRegel WHERE YEAR(Datum) = 2011 AND MONTH(Datum) = 11 AND DAY(Datum) BETWEEN 13 AND 19 AND

MenuItem = ‘Garnalencocktail’ Let op het onderdeel waar wordt aangegeven dat de dag tussen 13 en 19 moet liggen. Je mag in dit geval ook aangegeven: DAY(Datum) IN (13, 14, 15, 16, 17, 18, 19). Je kunt nu al aardig wat overzichten maken. Om te oefenen daarom de volgende opdracht. Opdracht: hoeveel bier is er in de eerste zeven dagen van de maand november 2011 verkocht? En hoeveel wijn?

SELECT COUNT(MenuItem) Aantal FROM BestelRegel WHERE YEAR(Datum) = 2011 AND MONTH(Datum) = 11 AND DAY(Datum) IN (13, 14, 15, 16, 17, 18, 19) AND MenuItem = ‘Kippensoep’ UNION SELECT COUNT(MenuItem) Aantal FROM BestelRegel WHERE YEAR(Datum) = 2011 AND MONTH(Datum) = 11 AND DAY(Datum) IN (13, 14, 15, 16, 17, 18, 19) AND MenuItem = ‘Tomatensoep’

Het UNION-keyword zorgt ervoor dat de resultaten van de twee afzonderlijke query’s worden samengevoegd. Op die manier kun je zien hoeveel soep er van iedere soort is gebruikt.

Opdracht: maak nu een query waarin op een overzichtelijke manier wordt weergegeven hoeveel desserts er van elke soort zijn verkocht op de zondagen in november 2011.

Opdracht: wat is de omzet geweest per MenuItem in november 2011?


6.3 Aggregatie In de laatste voorbeelden werd vaak gevraagd naar overzichten per categorie. SQL biedt de mogelijkheid om te groeperen. Dat wordt ook wel ‘aggregatie’ genoemd. Het wordt gedaan met behulp van de keywords GROUP BY.

Per uniek item wordt er slechts één weergegeven.

Bijvoorbeeld:

SELECT MenuItem FROM BestelRegel GROUP BY MenuItem ORDER BY MenuItem Opdracht: ga na dat het resultaat hiervan een gesorteerde lijst van 22 menu-items is.

GROUP BY kan ook op de volgende manier gebruikt worden in plaats van het eerder gebruikte keyword DISTINCT.

SELECT YEAR(Datum) as jaar, MONTH(Datum) as maand, DAY(Datum) as dag FROM BestelRegel GROUP BY YEAR(Datum), MONTH(Datum), DAY(Datum) ORDER BY YEAR(Datum), MONTH(Datum), DAY(Datum)

Opdracht: ga dit na.

Het nut van GROUP BY is om informatie samen te voegen via zogenaamde ‘aggregatiefuncties’. Voorbeelden hiervan hebben we al eerder gezien: COUNT en SUM.

Een voorbeeld

SELECT COUNT(MenuItem), MenuItem FROM BestelRegel GROUP BY MenuItem Resultaat


De lijst is nog niet gesorteerd. In dit geval sorteren we hem naar aantal en dan wel aflopend (DESC). SELECT COUNT(MenuItem) as Aantal, MenuItem FROM BestelRegel GROUP BY MenuItem ORDER BY Aantal DESC

Op deze manier is het mogelijk om bijvoorbeeld overzichten te maken van de best verkopende producten en de slechtst verkopende producten. Andere aggregatiefuncties zijn de volgende.

COUNT; geeft het aantal elementen SUM; geeft de som van een aantal elementen AVG; geeft het gemiddelde van een aantal elementen MIN; geeft het minimum van een aantal elementen MAX; geeft het maximum van een aantal elementen

Er kan ook over meer kolommen worden gegroepeerd. Het volgende voorbeeld laat dit zien.

SELECT BaanNummer, MenuItem, SUM(Prijs) FROM BestelRegel GROUP BY BaanNummer, MenuItem ORDER BY BaanNummer, MenuItem Opdracht: voer deze query in en controleer het resultaat.

Opdracht: bepaal de omzet per baan in de tweede week van november 2011.

6.4 Normalisatie Database tabellen worden vaak ‘genormaliseerd’. Met het proces van normalisatie probeer je structuur aan te brengen tussen verschillende database-tabellen met de volgende twee doelen.

1 Voorkomen van fouten zoals datadoublures. Denk aan verschillende manieren om een naam te spellen: Van Dijk, van Dijk, Dijk, Van, v Dijk, v. Dijk enzovoort. Een programma kan geen onderscheid maken tussen deze namen en deze worden allemaal als verschillende personen gezien, terwijl het misschien dezelfde persoon is.


2 Beperken van hoeveelheid informatie. Als een klant bijvoorbeeld meer consumpties bestelt, is het onzin om bij elke bestelling alle klantinformatie opnieuw op te slaan.

De bestellingen in het bonnenprogramma worden opgeslagen in de tabel BestelRegel. De lijst met menu-items is opgeslagen in een tabel genaamd MenuRegel.

Normaliseren heeft een aantal grote voordelen maar ook wel nadelen. Zo kan in veel gevallen informatie niet meer uit een enkele tabel worden gehaald, maar moeten meer tabellen worden gecombineerd. We noemen dat ‘joining tables’.

De eerste kolom, MenuTypeNaam, heeft vaak dezelfde informatie. Dat heeft een aantal nadelen. Een nadeel is de kans dat de inhoud kleine (foute) verschillen vertoont. Bijvoorbeeld Desert in plaats van Dessert. Een ander nadeel is dat het natuurlijk veel ruimte in de database inneemt om deze kolom steeds weer op te slaan.

Daarom wordt een veld dat meer keren wordt gebruikt, vaak opgeslagen in een aparte tabel. Dat scheelt ruimte en er is geen kans meer op foute spelling. Het is een onderdeel van eerdergenoemde normalisatie.


Hier volgt een voorbeeld hoe zo’n opsplitsing kan worden gemaakt.

De tabel MenuRegel is verdeeld in twee andere tabellen, MenuType en Menu.

Via het veld MenuTypeID verwijst een regel in Menu naar een MenuType regel.

De MenuType tabel bevat nog maar vier rijen, namelijk Voorgerecht, Hoofdgerecht, Dessert en Dranken.

Vanuit de tabel Menu wordt via een identifier (getal) verwezen naar een rij in de tabel MenuType.

Opdracht: bekijk de inhoud van de twee tabellen en bekijk hoe de samenhang is. Wat is de waarde van MenuTypeID in beide tabellen?

Het resultaat van SELECT * FROM MenuType

Het resultaat van een deel van: SELECT * FROM Menu


Zoals je ziet, verwijst de regel met MenuID = 9, Spaghetti bolognese, gekoppeld via MenuTypeID = 2. In de tabel MenuType wijst de waarde 2 naar Hoofdgerecht.

Om nu de informatie uit de twee tabellen te combineren gaan we een ‘join’ toepassen. We moeten informatie uit twee tabellen halen en aangeven via welk veld ze zijn gekoppeld.

SELECT MenuType.MenuTypeID, MenuType.MenuTypeNaam, Menu.MenuID, Menu.Aktief, Menu.MenuNaam, Menu.Prijs

FROM MenuType, Menu WHERE MenuType.MenuTypeID = Menu.MenuTypeID Dit levert het volgende resultaat op.

Om het beter leesbaar te maken kun je gebruikmaken van aliasnamen of afkortingen voor de tabellen. Hierdoor is minder typewerk nodig. SELECT mt.MenuTypeID, mt.MenuTypeNaam, m.MenuID, m.Aktief, m.MenuNaam, m.Prijs FROM MenuType mt, Menu m WHERE mt.MenuTypeID = m.MenuTypeID De naam MenuType is dus afgekort tot mt en Menu tot m. Het zal duidelijk zijn dat de informatie die in de verschillende tabellen staat, ook weer met elkaar kan worden gekoppeld. Dat verloopt over het algemeen via een sleutelveld. Opdracht: is het mogelijk om de tabel BestelRegel ook te koppelen met de tabel Menu? De voordelen hiervan zijn natuurlijk dat de namen van de menu-items in dat geval niet hoeven te worden gereproduceerd. Hoe zou dat moeten worden uitgevoerd?

6.5 Data wijzigen Uiteraard moet informatie in de database kunnen worden gewijzigd. In de database voor het bestelsysteem worden bestelregels toegevoegd. Het menu kan er ook worden onderhouden. Er kunnen menu-items worden toegevoegd of inactief worden gemaakt (menu-items worden niet verwijderd maar als ze niet meer op het menu staan, worden ze op ‘inactief’ gezet. Dan kunnen ze later nog wel in overzichten worden gebruikt, ook al staan ze niet meer op het menu).

De data worden gewijzigd met behulp van de volgende SQL-statements.


1 INSERT; hiermee kunnen rijen aan de database worden toegevoegd. 2 UPDATE; hiermee worden velden in rijen aangepast. 3 DELETE; hiermee worden rijen verwijderd.

6.6 INSERT Het toevoegen van data gaat als volgt.

INSERT Menu (MenuNaam, Prijs, Aktief, MenuTypeID) VALUES (‘Melk / Karnemelk’, 1.75, ‘j’, 4) Als je hierna controleert met SELECT * FROM Menu, dan zie je het volgende resultaat.

Het veld MenuID heeft geen waarde mee gekregen in de INSERT. Die waarde wordt automatisch door de database aangemaakt. Met het veld Aktief wordt aangegeven of een menu-item op het menu moet komen.

Als je nu bij de dranken kijkt in het bestelprogramma, dan zie je dat het laatste item erbij staat.

Opdracht: voeg zelf nog een voorgerecht, een hoofdgerecht en een dessert toe. Let op dat MenuTypeID verwijst naar de juiste rij in de tabel MenuType. Controleer met het bestelprogramma of de menu-items op de juiste plek staan.

6.7 UPDATE We gaan nu wat items uit het menu verwijderen. Dat doen we door het veld Aktief van de desbetreffende rij op ‘n’ te zetten.


We doen dit niet door de rij te verwijderen wat misschien meer voor de hand lijkt te liggen. Als je in dit geval een rij helemaal verwijdert, komt hij inderdaad ook niet meer in het menu voor maar kan hij ook niet meer in overzichten worden gebruikt. Het werken met een ‘Aktief-item komt heel veel voor in databases.

Stel bijvoorbeeld dat biefstuk van het menu afgehaald moet worden.

UPDATE Menu SET Aktief=‘n’ WHERE MenuID = 6

Gevolg:

Opdracht: maak het MenuItem van Biefstuk weer actief en controleer of het weer in het menu staat.

6.8 DELETE In sommige gevallen moeten er items uit een database worden verwijderd. Meestal is het beter om de rijen die niet meer mogen meedoen met een vlag op inactief te zetten. Dan blijft de historische informatie namelijk behouden.

Een rij uit een lijst verwijderen gaat als volgt.

DELETE Menu WHERE MenuID = 23

Hiermee wordt dus de rij met MenuID gelijk aan 23 verwijderd.


Let er bij zowel UPDATE als DELETE op dat de WHERE clause aanwezig en correct is. Zo zal het SQL-statement DELETE Menu tot gevolg hebben dat alle elementen worden verwijderd. En de statement UPDATE Menu SET Prijs = 1.25 zet de prijs van alle elementen van het menu op 1.25.


7 Aan de slag met HTML Je hebt nu al aardig wat ervaring met verschillende programmeertalen. Daarom vraagt John je voor een heel nieuw project: een website. In eerste instantie zal deze website voor intern gebruik zijn en later zal de website worden uitgebouwd naar een website voor extern gebruik.

Je besluit in eerste instantie om de basistaal van het internet te leren, HTML. Hoewel er veel omgevingen zijn waar je op een eenvoudiger manier websites kunt maken, is de taal waarmee tussen computers van het world wide web wordt gecommuniceerd, HTML. Daarom moet iedereen die iets met internet wil doen, een beetje van HTML afweten.

Als je in een webbrowser (bijvoorbeeld Microsoft Internet Explorer, Google Chrome of Mozilla Firefox) een internetadres intikt, bijvoorbeeld www.cxii.net, dan wordt via het internet contact gezocht met een server waarop deze website is gepubliceerd. Deze website stuurt de hoofdpagina van de website terug naar jouw browser.

Een webpagina ontwikkelen in HTML kun je doen met bijvoorbeeld Kladblok of Scite. Het testen gebeurt met een webbrowser.

We beginnen met een heel eenvoudige webpagina.

Maak nu een map aan op het bureaublad van je computer, genaamd MijnWeb en sla de pagina hierin op onder de naam EerstePagina.html.

Als je nu op deze pagina dubbelklikt, dan opent deze in je standaardwebbrowser. Je krijgt het volgende te zien.

http://www.cxii.net/


Dit kan iets afwijken, afhankelijk van de configuratie van de computer. Het achterste venster toont de inhoud van de map MijnWeb. Op de voorgrond is Windows Internet Explorer geopend met daarin de inhoud van de zojuist gemaakte pagina. Let even op het adres van de pagina. In plaats van een URL staat in het adresveld gewoon de locatie van het bestand.

Zoals je ziet, bestaat de code uit de tekst met daaromheen twee zogenaamde tags. De tag <p> is de ‘open’-tag en </p> de ‘sluit’-tag. Let op de slash (/). Alles wat zich binnen een opentag een sluittag bevindt, voldoet aan de door die tags opgelegde regels. Zo definieert de combinatie <p></p> een paragraaf (of alinea). Alles wat zich tussen die tags bevindt, wordt weergegeven als een alinea.

Een nieuwe alinea kan de dan op de volgende manier toevoegen.

Merk op dat het niet uitmaakt op wat voor manier je de tags in het formulier zet. De browser interpreteert ze altijd hetzelfde. Het resultaat ziet er als volgt uit.


Zoals gezegd kun je met tags aanwijzingen geven over de opmaak (in het Engels de Markup) van de tekst. Daar komt de ook de naam HTML vandaan: HyperText Markup Language. We zullen nu een aantal tags laten zien.

Als eerste een tag die de grootte van de gebruikte letters bepaalt: h1, h2, h3, h4, h5 en h6. Hierbij is h1 het grootste font en h6 het kleinst.

Het resultaat in een webbrowser ziet er als volgt uit.


Tags kun je ook combineren. Als je er maar wel voor zorgt dat de volgorde van de opentags en sluittags klopt.

Bekijk het volgende voorbeeld.

De tag <br> staat voor een nieuwe regel. Het is de enige tag die geen sluittag nodig heeft.

<b> staat voor bold (vet) <i> staat voor italic (cursief) <u> staat voor underline (onderstreept) Het resultaat is als volgt.


Opdracht: tik bovenstaand voorbeeld in Scite in en probeer het op je eigen computer. Combineer het met alle h-tags (h1, h2 enzovoort).

7.1 Verwijzen naar andere pagina’s Bij websites vind je normaal gesproken bijna altijd verwijzingen (links) naar andere pagina’s. Zo’n verwijzing wordt ingebracht via een tag, genaamd ‘a’ (van Anchor of Anker).

De link van zo’n verwijzing ziet er als volgt uit.

<a href=”paginaadres.html”>Link naar andere pagina</a>

Achter href staat de verwijzing naar de pagina die moet worden geladen. Tussen de tags staat de tekst die bij de link moet staan. De volgende pagina geeft een voorbeeld hiervan.


Met als resultaat:

Opdracht: maak het bovenstaande voorbeeld. Controleer of de links werken. Opdracht: vergroot het lettertype naar h2 zoals hierna.


7.2 IMG, het weergeven van afbeeldingen Met behulp van een img-tag kunnen afbeeldingen worden weergegeven. Dat ziet er als volgt uit.

De afbeelding is van het png-formaat en stelt een glas bier voor.


7.3 Opmaak De pagina’s die tot nu toe zijn gemaakt, werken functioneel wel goed. Ze zien er echter niet mooi uit. HTML biedt heel veel mogelijkheden om de opmaak mooier te maken. Zeker met het zusje CSS (Cascading Style Sheets) is het mogelijk om zeer aantrekkelijke websites te maken. We zullen eerst kijken naar een aantal opmaakprincipes. Het is nuttig om de code een keer te zien, maar er zijn zeer veel programma’s op de markt waarmee opmaak interactief met knippen, plakken, slepen enzovoort kan worden uitgevoerd.

We gaan eerst kijken naar hoe je een webform kunt verdelen in vlakken. Vaak wil je namelijk een vaste indeling voor een webpagina maken. Bijvoorbeeld aan de linkerkant het navigatie gedeelte en aan de rechterkant de inhoud. Daarnaast is er ook nog vaak een verdeling in boven, midden en onder gemaakt.

Een vlakverdeling in een HTML-page maak je meestal met een tabel. Het ziet er als volgt uit.

Het resultaat hiervan is als volgt.


De tag <tr> definieert een rij en de tag <td> een cel.

Opdracht: tik de code van bovenstaand voorbeeld in en experimenteer met de tekst en het resultaat. Je kunt op deze manier ook plaatjes weergeven.

Het resultaat is als volgt.


Opdracht: controleer ook dit voorbeeld door het in te tikken.

7.4 Een echte webpagina Wat we tot nu toe hebben gezien, zijn eigenlijk nog geen echte webpagina’s. In echte webpagina’s staat namelijk aanvullende informatie. Zo is een pagina onder andere verdeeld in een <header> en een <body>.

Je ziet hier een voorbeeld.

Met het volgende resultaat.


Opdracht: tik dit voorbeeld in. Bewaar het op een aparte plek zodat je het steeds weer kunt gebruiken. Let op het resultaat (bijvoorbeeld de titel van de webpagina). Waar vind je de gedefinieerde onderdelen terug?

7.5 Opmaken met stijlen Vanaf HTML versie 4 (versie 5 is de laatste) zijn de zogenaamde ‘Cascading Style Sheets’, afgekort CSS geïntroduceerd. Met behulp van CSS kunnen stijleigenschappen worden gedefinieerd die voor bepaalde HTML-elementen gelden. Zo kun je aangeven dat een bepaald type font moet worden gebruikt met een bepaalde kleur.

Je kunt op de volgende manier CSS toevoegen aan websites of aan webpagina’s.

1 in het style attribute van HTML-elementen 2 in het <style> element in de HTML “head” section 3 in Cascading Style Sheet files (CSS files)

Omdat een style vaak een huisstijl als grondslag heeft, is het aan te raden om styles in aparte (css) bestanden op te slaan. Al je dan een keer een style wilt veranderen, hoef je dat alleen in de betreffende bestanden te doen en werkt de verandering door in alle webpagina’s.

Eerst een voorbeeld van het style attribute.

Achter <body> zie je gedefinieerd wat de stijl van de webpagina zelf is. Alle elementen in de body erven dit, tenzij dat anders wordt gedefinieerd in het element zelf. De achtergrond van het blad is dus geel, het gebruikte font is Verdana en de grootte van het font is 12 pixels.


Opdracht: probeer de code op de vorige bladzijde uit. Experimenteer met verschillende lettertypes (fonts), lettergroottes en kleuren. Een lijst van fonts is te vinden op internet.

Een voorbeeld van het <style> element ziet er als volgt uit.

Hier wordt Heading rood weergegeven, Paragraaf blauw. De vorm van de styledefinities is als volgt.

selector { property : value ; property : value….. }

In de selector wordt aangegeven welk element de properties krijgt toegewezen.

Opdracht: tik bovenstaand voorbeeld in en zorg ervoor dat de achtergrondkleur van de pagina groen wordt door een element aan de styletag toe te voegen.

Ten slotte een voorbeeld met het onder punt 3 genoemde Cascading Style Sheet files. De styles kunnen hierbij in een aparte file worden gedefinieerd. Vanuit elke HTML-file wordt dan verwezen naar hetzelfde stylebestand.


Er wordt gerefereerd naar het bestand ‘menustijlblad.css’. Dat bestand ziet er als volgt uit.

Opdracht: maak dit voorbeeld na en voeg daarna een property toe voor de achtergrondkleur van je pagina.

Opdracht: maak een opmaak voor de kegelbaan. Pas deze in eerste instantie toe op de menu webpagina.

Opdracht: maak een volledige menukaart met alle menu-items. Breng hierin dezelfde structuur aan, als in het kassaprogramma. Dus uitgaande van Menu kun je kiezen voor Voorgerecht, Hoofdgerecht … enzovoort. En onder bijvoorbeeld Voorgerecht kun je doorklikken naar de afzonderlijke items zoals Kippensoep. Zoek op het laagste niveau bij alle gerechten plaatjes op internet. Meestal zijn die in jpg-formaat. Zet ze met behulp van Paint om in png-plaatjes en plak ze in je webpagina. Voorbeeld:


7.6 Samenvatting HTML Je hebt nu een korte inleiding gehad in het maken van webpagina’s. Je bent in staat om zelf eenvoudige webpagina’s te maken met een eenvoudige opmaak.

Meer complexe webpagina’s met uitgebreidere opmaak bouwen en het direct koppelen van websites aan een database horen niet bij deze training. Dat wordt in het volgende deel behandeld.

Bijlage Leren programmeren 117

Bijlage I Voorbereidingen werkstation

Basic voor hoofdstukken 1 en 2 1 Installatie JustBasic

a Run de installatiefile jbwin101.exe. b Kies als installatiefolder c:\basic. c Kopieer de shortcut justbasic v1.01 vanuit het startmenu naar de desktop. d Installeer een van de WinHlp.exe bestanden (windows6.x-KB917607-xyz.msu).

Java voor hoofdstukken 3, 4 en 5 1 Installatie Scite

a Run de juiste scite-3.1.0 msi file. b Kopieer de shortcut Scite vanuit all programs|Scintilla Text Editor naar de desktop.

2 Installatie Java development kit

a Run de installatie file jdk-7u2-windows-i586. b Voeg het pad naar de java development kit directory (c:\program files (x86)\java\jdk

1.7.0_02\bin) toe aan de system variabele Path.

SQL voor hoofdstuk 5 1 Installatie en configuratie SQL Server 2008 R2 Express

a New installation or add features to existing installation. b Specify a free edition: Express. c Accepteer de defaultinstellingen. d Bij Feature Selection kies je Database Engine Services. e Bij Server Configuration kies voor het SQLServer Database Engine account een useraccount

met een password dat op ‘never expires’ staat. f In het Database Engine Configuration scherm kies voor je add current user onder specify SQL

Server administrators. g Vervolg de installwizard tot het einde.

2 Installatie SQL Management Studio R2

a Run de juiste installatie file SQLManagementStudio_xyz_ENU.exe. b Kies new installation or add features to an existing installation. c Voor Installation Type kies ‘New installation or add features’. d Vervolg de wizard.

3 Installatie SQL Interpreter

a Installeer Framework 4.0 Client Profile. b Run de SQLSetup.msi. c Hernoem de shortcut ‘Shortcut to SQLHoofdstuk’ naar ‘SQLInterpreter’. d Ga naar C:\Program Files (86)\Default Company Name\SQL Interpreter.

Bijlage Leren programmeren 118

e Open de configfile SQLHoofdstuk.exe.config en vervang ‘(local)’ door ‘localhost\sqlexpress’.

4 Restore de Kegelbaan.bak database a Start|All Programs|Microsoft SQL Server 2008 R2|SQL Server Management Studio. b Achter Server name: type localhost\sqlexpress en connect. c Klik rechts op Databases en kies Restore Database. d Selecteer From device en druk op de knop met … (drie puntjes). e In het scherm Specify Backup druk op de knop Add. f Browse naar het bestand kegelbaan.bak, en druk op OK. g Druk nog eens OK. h Achter To database type: Kegelbaan. i Vink aan Kegelbaan-Full Database Backup en druk op OK. j Sluit af met OK en sluit Management Studio.

5 DBBestel programma

a Kopieer de folder DBBestel met inhoud naar C:\. b Open de config file DBBestel.exe.config en vervang daarin ‘(local)’ door

‘localhost\sqlexpress’. c Zet een shortcut naar DBBestel.exe op de desktop.

leren programmeren

Documents