rd 2005 Elektronische uitgave 2006 Java 1

Transcriptie

1 2005 Elektronische uitgave 2006 Java 1

2 INTRODUCTIE 3 HOOFDSTUK 1 HET ONTSTAAN 4 HOOFDSTUK 2.ONS EERSTE APPLET 6 HOOFDSTUK 3 TEKENEN MET JAVA 8 HOOFDSTUK 4 KLASSEN EN OBJECTEN 12 HOOFDSTUK 5 VARIABELEN EN HUN TYPES 17 HOOFDSTUK 6 OPERATOREN. 22 HOOFDSTUK 7 ANDERE TYPES 25 HOOFDSTUK 8 METHODEN 31 HOOFDSTUK 9 STRING WERKING 34 HOOFSTUK 10 KLASSEN 39 HOOFDSTUK 11 KEUZEN, LUSSEN EN HERHALINGEN 49 HOOFDSTUK 12 CONTROLE VAN DE INVOER 58 HOOFDSTUK 13. STACK HEAP GARBADGE COLLECTOR 67 HOOFDSTUK 14. TABELLEN (ARRAY S). 69 HOOFDSTUK 15 OVERERVING 84 HOOFDSTUK 16. GEBRUIKERS INTERFACE 89 HOOFDSTUK 17. ONTWERPEN VAN APPLICATIES 103 Java 2

3 Introductie Java is een bijzondere programmeertaal. Voor 1995 had nog niemand of bijna niemand daarover gehoord. Een paar jaar later in Java zelfs bekend bij mensen die nooit een programma geschreven hebben. Laat ons in verdere hoofdstukken Java een plaats geven tussen de andere programmeertalen. Java 3

4 Hoofdstuk 1 Het ontstaan Java is in de jaren 90 ontworpen in de hoop dat deze taal zou gebruikt worden voor de programmering van alle soorten elektronisch apparatuur, zoals kopieer machines, afstand bedieningen, televisies enz. Zulk een soort apparatuur is voorzien van een chip waar de meeste instructies van wat het moet doen in opgeslagen is. Toen men probeerde om deze apparatuur het herprogrammeren kwam men al gauw tot de ontdekking dat het een tijdrovend en kostelijk iets was voor de industrie en dat om reden dat er geen standaardisatie was in programmeer talen. Dit was tevens een probleem voor de PC. Niet iedere PC had het zelfde operating systeem en daarom kan het voorkomen dat een geschreven programma voor een PC niet kan werken op een andere PC met een ander operating systeem. Denk maar aan een verschil tussen Windows (Microsoft) en Apple, of zelfs Linux. Zelfs als begint met de soorten processoren heeft men problemen een Intel processor en een Motorola processor of zelfs een Sparc processor kunnen problemen geven met de programmering taal. Daardoor gaan we eens kijken naar het inwendige van een programmering. De taal waarin geprogrammeerd wordt, zij het nu Engels of Nederlands speelt in feite geen rol. De functie van de programmeer taal is in feite normale taal om te zetten naar een taal die de PC begrijpt. Namelijk machinetaal. Daarom moet er een programmeer taal gebruik maken van een soort vertaler ook compiler genoemd. Zolang je als programmeur werkt met één systeem is het gemakkelijk om dat je maar één soort machinecode hebt. Als je echter tussen soorten computers moet werken wordt dat een beetje moeilijker, immers de processoren hebben allen een andere code. Als men dan nog begint te verwisselen in besturing systemen zal men nog andere problemen tegen komen. De samenhang tussen de processor en het besturingssysteem noemt men het platform. Dus de oplossing was een taal ontwerpen die NIET meer afhankelijk was van en bepaald platform, maar die kon werken op verschillende platformen. Immers het was een onmogelijke taak voor ieder platform een ander programma te schrijven. 1.1 En dan is er Java Een groep van SUN, geschaard rond James Gosling heeft daar getracht een oplossing voor te vinden. Het idee was, en dit zoals de meeste goede ideeën, zeer simpel. - laat elk Java programma door een compiler vertalen naar en soort standaard tussentaal die betrekkelijk dicht bij de machine code zit. - Voorzie dan elke processor met een programma die deze tussen code begrijpt en ze vertaald voor de specifieke computer. Java 4

5 Deze tussen taal noemt men de Java-byte code, en het programma dat deze code begrijpt noemt men de Java Virtual Machine (JVM). Omdat de vertaling van de byte code niet zo een groot probleem, is kan men gemakkelijk een klein programmaatje van JVM maken De verspreiding van de JVM is geen probleem. Daarvoor kan men Internet gebruiken. Waardoor de verspreiding redelijk soepel gebeurt. Daardoor zijn alle problemen opgelost, in die verstande dat de computer over het programma JVM beschikt. Maar na 1995 is dat gemeen goed geworden en de meeste browser hebben reeds een ingebouwde JVM. Met de Java taal 2 soorten programma s bouwen. Dit zijn de applicaties en Applet. Een applicatie is een programma dat volledig op zijn eigen kan bestaan. Een Applet daar en tegen kan enkel werken in samenwerking met een browser of Applet viewer. Wij zullen ons vooral bezighouden met het schrijven van Applet s. 1.2 Hoe werkt zo een programma Voor wie nog nooit geprogrammeerd heeft, en dat is bij ons niet het geval, is het goed om weten dat men het Java programma moet inbrengen in een editor. Nadien moet men de geschreven tekst bewaren als een bestand met als achtervoegsel.java Daarna vertalen we dit met de compiler. De compiler heeft 2 functies. Enerzijds het controleren op fouten, programmeurs zijn ook maar mensen, en anderzijds deze Applet vertalen naar de byte code. Vervolgens wordt de Applet door middel van een Applet viewer getoond. Wij maken het ons echter gemakkelijk. De firma Borland heeft verschillende Java compiler uit gebracht dat al die zaken voor ons combineert. Wij gebruiken dan ook JBuilder 6 als editor-compiler. De huidige Jbuilder 8 en 9 kunnen ook daarvoor gebruikt worden. Java 5

6 Hoofdstuk 2.Ons eerste Applet We starten onze JBuilder op en maken een project. Dit project bewaren we op een juiste plaats op onze computer. Nadat we een project hebben maken we een Applet. Let op geen applicatie. Bij het maken van deze Applet zal direct een aantal lijnen geproduceerd worden. Voor het gemak kan men alles na de lijn : public class.. tot juist voor de laatste accolade wissen. Dan krijgt men ongeveer onderstaande tekst. Daarin kunnen we volgende stukken bemerken. De eerste lijn spreekt van de pakkage of de naam van ons project. Nadien hebben we een paar lijnen beginnende met import. import Java.awt enz... Dit duidt dat er een bibliotheek van awt geladen zal worden. Er zijn verschillende soorten bibliotheken. Verder gaan we dit nog in de puntjes behandelen. Merk op dat nadien er een paar commentaar regels geschreven zijn. Commentaar regels in Java staan tussen de tekens /*..*/. Als men maar één regel commentaar wil aanduiden kan men de aanduiding // gebruiken. Het programma begint met public class. Extends Applet en dan een open accolade. Deze accolade staat voor het begin van het programma. package eerste; import java.awt.*; import java.awt.event.*; import java.applet.*; /** * <p>title: </p> Java 6

7 * <p>description: </p> * <p>copyright: Copyright (c) 2004</p> * <p>company: </p> not attributable 1.0 */ public class Applet1 extends Applet { public void paint( Graphics g) { g.drawstring("de eerste Applet is steeds de moeilijkste",10,10); In volgende instantie hebben we ons programma een beetje uitgebreid. U ziet dat we een methode hebben bij ingebracht, nl. de methode paint(). De opdracht g.drawstring is vervat in de methode paint(). Let op de schrijfwijze van drawstring, zoals vroeger al gezegd is Java case sensitive dus moet men opletten hoe men iets schrijft. De uitslag van deze Applet is: 1 Figuur 1 De meeste van de commando s in Java kunt u vinden door gebruik te maken van de help functie. Dit is een nuttig gereedschap voor het programma schrijver en ik dring er op aan dat u dit zoveel mogelijk in de komende maanden tracht en leert gebruiken. Opgave 1 maakt een Applet welke uw naam afdruk op het scherm. Gebruik de methode paint() om dit te verwezenlijken. Vergeet niet eerst een analyse te maken volgens N.S. 1 Dankzij het gebruik van Borland Jbuilder zal de uitslag van onze applet direct vertoond worden in de applet viewer Java 7

8 Hoofdstuk 3 Tekenen met Java 3.1 Schermcoördinaten (0,0) (320,0) (0,240) (320,240) De coördinaten beginnen linksboven met 0,0. De x-coördinaat neemt toe van links naar rechts en de y-coördinaat van boven naar onder. Als de grote van de Applet 320 x 240 is kunt u de maten analoog gebruiken. Is de maat afwijkend moet u natuurlijk de afwijking met de zelfde factor aanpassen. 3.2 tekenen van een lijn Het tekenen van een lijn of figuur (cirkel, vierkant rechthoek) is net zo eenvoudig als het plaatsen van een tekst. Daar bestaan ook speciale opdrachten voor. Voor een lijn is die g.drawline(x1,y1,x2,y2) De coördinaten x1,y1 en x2,y2 zijn respectievelijk het begin en eind coördinaten van de lijn. De letter g in dit commando heeft zoals in de paint commando s de grafische context weer. public class applet2 extends Applet { public void paint (Graphics g){ g.drawline(0,0,100,200); Java 8

9 Figuur 2 Bovenstaande commando en figuur geven hoe een lijn getekend wordt. Bemerk hoe de coördinaten uitgetekend zijn op het applet. Opgave 2. Construeer een applet met JBuilder die een rechthoekige driehoek op het scherm brengt. De top begint op 10,10 en het basis ligt op 200, Kleur op een applet Er zijn in Java 13 kleuren beschikbaar. Deze kleuren beginnen met Color.naam. Als je bij het tekenen of neerzetten van een tekst een kleur wilt toepassen, dan gebeurt dit in de methode paint() met het commando g.setcolor(color.naam) de kleuren voorradig zijn: black blue cyan darkgray gray green lightgray magenta orange pink red white yellow 3.4 Rechthoeken en ellipsen Er zijn speciale commando s voorzien om het tekenen van rechthoeken en ellipsen. Met het commando drawstring kunt u een tekst neerzetten in een applet. Met het commando drawline kan men lijnen tekenen. Voor het plaatsen van een rechthoek hebben we dan analoog g.drawrect(x1,y1,x2,y2) (x1,y1) lengte(x2) Breedte(y2) Java 9

10 Terug zijn de coördinaten van cruciaal belang. Hier duid men het begin punt aan op het canvas en de lengte en de breedte van een rechthoek. We hebben ook een commando om het tekenen van een ellips te vergemakkelijken. Dit is in de methode paint(): g.drawoval(x1,y1,x2,y2) (x1,y1) x2 Y2 Terug zijn x2 en y2 de lengte en de breedte van de rechthoek maar nu waarin het ovaal getekend wordt. public class Applet3 extends Applet { public void paint (Graphics g){ g.drawrect(10,10,100,50); g.drawoval(10,80,100,50); Figuur Rondingen en bogen Er bestaan, zoals we reeds gezien hebben, verschillende methoden in de Java taal om figuren op ons beeldscherm te brengen. De methoden drawrect, drawoval, fillrect. Java kent echter nog andere methoden om figuren op uw scherm te brengen. drawroundrect() tekent een rechthoek met afgeronde hoeken fillroundrect() vult deze op met een bepaalde kleur drawarc() tekent een open boog fillarc vult deze op Java 10

11 Figuur 4 Deze methoden zijn hierboven gebruikt. De opdrachten zijn drawroundrect(intx,inty,intwidth, intheigth,intarcwidth,intarcheigth) De methode drawarc() drawarc(intx,inty,intwidth,intheigth,intdrawangle,intarcangle) Nog een kleine opmerking: hoeken mogen negatief zijn. Immers negatieve hoeken worden getekend met de klok mee en positieve tegen de klok in. Opgaven: 1. teken een applet welke een stoplicht voorstelt. 2. drie kinderen hebben de volgende lengtes charlot 105 cm isabel 120 cm jacob 65 cm Teken een staafdiagram in een applet waarbij iedere rechthoek een andere kleur heeft, en noteer welke naam bij welke kleur Java 11

12 Hoofdstuk 4 Klassen en objecten Java is een object georiënteerde programmeertaal. We werken dus met objecten. Een object kan in principe van alles zijn dat zichtbaar is op het scherm. Het kan een knop of een venster zijn maar het kan ook gegevens zijn van een persoon, adres geboortedatum enz. Een object is in feite de bouwsteen van een object georiënteerde programmeertaal. Als je een computer wilt laten werken met een object moet je precies vaststellen waaruit zo een object bestaat. Een beschrijving van een object wordt de klasse van een object genoemd. Heel veel beschrijvingen voor verschillende objecten wordt bewaard in een klasse bibliotheek (class libary). Deze is op zijn beurt op geborgen op de schijf en wordt aangesproken door de import regel in het begin van een programma. 4.1 Klasse Font en het font object Als je een tekst op een applet plaatst (tekent) kan men kiezen ui t verschillende Fonts Oorspronkelijk wordt een zeer kleine standaard lettertype gebruikt, maar door gebruik te maken van het object font kan men daarin verandering brengen. 8.1 De klasse Font De manier waarop je grotere letters krijgt is typisch voor een object georiënteerde taal. Het soort letter dat je wilt gebruiken moet een object zijn in je programma. Een object kan je echter maar maken als je beschikking hebt over een klasse. In de ingebrachte klasse Java.awt is er een klasse Font. Deze klasse ziet als volgt uit: FONT Name Style size Figuur 5 Deze figuur, die ook de inhoud van het object Font is met zijn eigenschappen, geeft een beschrijving van het object Dit zijn de naam, stijl (cursief, bold) en de grootte van de letter. Op grond van deze klasse kan je een kletter modelleren en concrete objecten maken. 8.2 Font Object Zoals we hierboven zagen bestaat het font object uit 3 attributen, te weten naam, stijl en grootte, in overeenstemmin met de attributen vernoemt in de klasse. We geven eens een voorbeeld: Java 12

13 Naam: TimesRoman Aral Helvetica enz. Voor de stijl kan je kiezen uit: Font.PLAIN Font.BOLD Font.ITALIC De grootte is een geheel getal, dat geschreven wordt in punten. Zo kan men Font objecten maken: TimesRoman,BOLD, 24 punten Arial,ITALIC,12 punten enz 8.3 Font object in een applet import java.awt.*; import java.awt.event.*; import java.applet.*; /** * <p>title: </p> * <p>description: </p> * <p>copyright: Copyright (c) 2004</p> * <p>company: </p> not attributable 1.0 */ public class Applet1 extends Applet { Font f; public void init(){ f=new Font("TimesRoman",Font.BOLD,24); public void paint(graphics g){ g.setfont(f); g.drawstring("een andere letter",10,20); Figuur 6 In figuur 6 zien we de uitwerking van de code van erboven. Hier in kunnen we en paar gedeelten opmerken die leiden tot de structuur van en applet. Java 13

14 - de declaratie van het Font-object f. - de methode init() waar de voorbereidingen gebeuren ingeval men een nieuw object maakt - de methode paint die uiteindelijk de tekst op het canvas tekent. 4.2 Een object: de grafische context Steeds komen we de methode paint() tegen. Dit zal steeds gebruik maken van een object. Dit wordt hier g genoemd. Als we iets tekenen hebben we steeds de verwijzing naar dit object nodig bijvoorbeeld g.drawline() of g.drawstring() Deze maakt gebruik van de klasse Graphics genaamd. Een instantie van deze klasse is dan g. 4.3 Namen in Java In Java is niet elke naam die men verzint bruikbaar. Namen van objecten, klassen en methoden moeten voldoen aan een vaste regelgeving. Een naam mag je opbouwen uit: - kleine letters zoals a,b,c - hoofdletters zoals A,B,C - cijfers zoals 1,2,3 - onderscore _ - dollar teken $ De namen mogen zolang zijn zoals je zelf verkiest maar mag NOOIT beginnen met een cijfer 4.4 Gebruik van hoofd en kleine letters Zoals al veelmalen gezegd is Java hoofdletter gevoelig.( Case sensitive). - Namen van klassen beginnen altijd met een hoofdletter - Namen van objecten beginnen over het algemeen met een kleine letter - Namen van objecten geven aan wat de inhoud is - Bestaat een naam van een object uit twee of meer woorden dan zal ieder begin van een nieuw woord een hoofdletter zijn. Gelieve deze regel rigoureus toe te passen, het zal je helpen in het programmeren 4.5 Een knop import java.awt.*; import java.awt.event.*; import java.applet.*; /** * <p>title: </p> * <p>description: </p> * <p>copyright: Copyright (c) 2004</p> * <p>company: </p> not attributable Java 14

15 1.0 */ public class Applet2 extends Applet { Button knop; public void init(){ knop = new Button(); knop.setlabel("druk hier"); add(knop); public void paint(graphics p){ p.drawstring("wat doet die knop hier",20,20); Met bovenstaande code zullen we een knop op het canvas aanbrengen. In principe gaat er niets gebeuren als we op de knop klikken. Het enige dat we nu gedaan hebben is een knop op het canvas zetten. Een beetje meer uitleg: We declareren eerst een object, Button en geven het een variabele naam knop In onze init() methode zullen we eerst de knop een bestaan geven door hem temaken met de constructor new Button. Met dit commando maken we nieuw object. Een van de instanties van Button is setlabel Daarmede zullen we op de knop een tekst aanbrengen. Door het commando add(knop) zullen we de knop op het canvas zetten. Zoals voordien aangehaald gebeurt er niets als we op de knop klikken. Daarvoor hebben we een event nodig. De werking met een event noemt men event handling. We gaan eerlang de event handeling bespreken maar gaan eerst nog iets toevoegen aan onze applet, namelijk een tekstvak waarin we zelf een tekst moeten schrijven 4.6 Tekstvak object import java.awt.*; import java.awt.event.*; import java.applet.*; /** * <p>title: </p> * <p>description: </p> * <p>copyright: Copyright (c) 2004</p> * <p>company: </p> not attributable 1.0 */ public class Applet3 extends Applet { TextField tekstvak; public void init() { tekstvak = new TextField(20); tekstvak.settext("dit is een tekstvak"); add (tekstvak); Java 15

16 public void paint(graphics g){ g.drawstring("klik eerst in het vak",20,20); Als je deze code uitvoert e je klik in het tekstvak kan je zelf een tekst invoegen. We weten nu hoe je een knop op het canvas zet en hoe je een knop op het canvas zet. Nu gaan we beiden aan elkaar koppelen. 4.7 werken met een event import java.awt.*; import java.awt.event.*; import java.applet.*; /** * <p>title: </p> * <p>description: </p> * <p>copyright: Copyright (c) 2004</p> * <p>company: </p> not attributable 1.0 */ public class Applet4 extends Applet { Button knop; TextField tekstvak; public void init(){ //maken en toe voegen van de objecten knop = new Button("klik hier"); tekstvak = new TextField("dit is een tekstvak",20); add(knop);add(tekstvak); public void paint(graphics g){ g.drawstring("probeer het",100,100); /* met de volgende methode gaan we maken dat we op de knop kunnen klikken en dat er iets gebeurt*/ public boolean action(event e, Object o){ if(e.target == knop){ tekstvak.settext("foei, je hebt geklikt"); return true; return false; Met deze code krijgt men de applet van figuur 7. Door op de knop te klikken zal de tekst, foei je hebt geklik verschijnen in het testvak. Java 16

17 Dit gebeurt met de methode public boolean action (Event e, Object o). Met het commando if(e.target == knop) kunnen we de knop aanspreken. e, de event wordt gekoppeld aan het object de knop. Verdere bespreking van dit commando zal verder in de cursus volgen. In deze methode staat ook nog return true en na afhandeling Oefeningen Figuur 7 return false. De juiste bedoeling daarvan zal ook verder uitgelegd worden. Het leuke zou nu zijn zouden we een knop toevoegen dat de tekst terug wist. Dit gebeurt met het commando dat de tekst opheft nl: set.text( ). Plaats eens een knop bij die dat doet. Ontwerp een applet met twee tekst velden en een knop. Men moet in beide tekstvelden een tekst zetten. Met het drukken op de knop moeten beide velden leeg zijn. Maak een applet met een tekst vak met daarin de tekst hoe is het. Bij het klikken op een knop moet deze tekst veranderen in goed, dank u. Plaats bij de eerste oefening een knop dat het lettertype veranderd bij klikken. Hoofdstuk 5 variabelen en hun types Zoals in iedere programmeertaal is ook het gebruik van variabelen belangrijk in Java. We weten al, van de vorige jaren, dat variabelen in feite een plaats in het geheugen is dat we reserveren om bepaalde data in te stockeren. Met deze data kunnen we dan gedurende het programma werken. Zoals in iedere programmeertaal bestaan er ook lokale en globale variabele. Daar gaan we echter verder met geconfronteerd worden, en zullen ten gepaste tijde er verder over spreken. Wat ons in eerste instantie Java 17

18 aanbelangt is het type(s) dat een variabele met zijn om met deze te kunnen werken. We kennen in Java nog andere verdelingen nl: - Variabelen die naar en object verwijzen in Java hebben een speciale naam. Die noemen we referenties. - Variabelen die betrekking hebben tot een primitief type. De primitieve typen zijn in Java: byte, short, int, long, float, double, char en Boolean De eerste 6 types hebben allemaal te maken met getallen en berekenen. We gaan elk van hen dieper bespreken in de volgende pagina s Het type int. In dit soort variabelen kan men in Java gehele getallen in opbergen. Men kan ook spreken van en int-variabele. Integer is ons al lang bekend, ik denk maar aan Pascal, Visual Basic enz. Voordat we echter een variabele kunnen gebruiken moeten we deze laten kennen aan de PC, of met andere woorden we moeten hem declareren. Daarmee wordt 2 dingen bedoeld. - de variabele moet een type krijgen - de variabele moet een naam krijgen. Voorbeeld het optellen van getal 10 en getal 20 gebruik makend van variabelen import java.awt.*; import java.awt.event.*; import java.applet.*; public class variabele1 extends Applet { public void paint(graphics g){ //declareren van de variabele int getal1; int getal2; int uitslag; getal1 = 10; getal2 = 20; uitslag = getal1 + getal2; //toon de uitslag g.drawstring("we bekomen als we " + getal1 + " en "+ getal2 + " optellen: ",50,100); g.drawstring("als resultaat: "+ uitslag, 50,110); Figuur 8 In bovenstaand voorbeeld zullen we het begrip assignment gebruiken. Dit is het toewijzen van een waarde aan een variabele. De variabele staat in dit geval aan de Java 18

19 linkerkant van het = teken. Hier zullen we een vast getal ingeven. Dit wordt ook literal genoemd. Hier is het een literal van het type int. Dit is echter niet noodzakelijk. Het is immers volstrekt mogelijk dat een expressie kan toegewezen worden aan een variabele. De variabele zal zich dan gedragen als de uitkomst van die expressie: - uitslag = getal1 + getal2; - uitslag = 3*a + 4*b; 5.2 Lokale variabelen en object variabelen Om terug te komen op het begin van dit betoog zullen we het nu in het kort hebben over lokale variabelen en globale of object variabelen. Het verschil is zeer vanzelfsprekend. Kijken we naar vorig voorbeeld dan zien we dat de variabelen getal1 en getal2 van het type int, gedeclareerd worden in het begin van de methode paint(). Deze variabelen worden daarom lokale variabelen genoemd. Het is ook volstrekt mogelijk deze variabelen te declareren in het begin van de klasse, zoals in onderstaande code import java.awt.*; import java.awt.event.*; import java.applet.*; public class variabele1 extends Applet { int getal1; int getal2; int uitslag; public void paint(graphics g){ //declareren van de variabele getal1 = 10; getal2 = 20; uitslag = getal1 + getal2; //toon de uitslag g.drawstring("we bekomen als we " + getal1 + " en "+ getal2 + " optellen: ",50,100); g.drawstring("als resultaat: "+ uitslag, 50,110); In dit geval spreekt men van object variabelen of instance variables Principieel maakt de plaats van declaratie geen verschil. Echter zoals onderstaande figuur aanduidt is er een verschil in die verstande dat object variabelen over gans het programma, dus in alle methoden te gebruiken is. Lokale variabelen echter kunnen we enkel gebruiken in die methode waarin ze gedeclareerd zijn public class variabele1 extends Applet { int getal1; int getal2; int uitslag; Java 19

20 public void paint(graphics g){ //declareren van de variabele getal1 = 10; getal2 = 20; uitslag = getal1 + getal2; public boolean action(event e, Object o){ getal1 ; getal2 ; uitslag...; Figuur 9 Dit wordt nogmaals onderstreept in figuur 9 waar de werking van de globale soorten variabelen uit blijkt. 5.3 Verkorte notatie, declaratie en initialisatie In vorige oefening hebben we verschillende regels gebruikt. 1 voor de declaratie en 1 voor de initialisatie Verkorte notatie Inde plaats van 3 regels te gebruiken voor de declaratie van 3 variabelen, kan men dit ook in 21 regel. Dit in analogie met andere programmeertalen: int getal1; int getal2; = int getal1, getal2, uitslag; int uitslag; Daaruit kunnen we afleiden dat de compiler alles aanvaard tot aan de afsluitende ; als een zelfde type. Zo kan je ook plaatsen: int getal1, getal2 uitslag; dit wordt ook door de compiler begrepen Declaratie en initialisatie Het is ook mogelijk om direct na de declaratie van de variabelen ze en waarde mee te geven. int getal1 = 10, getal2 = 20, uitslag = 0; Dit is voornamelijk bruikbaar bij het gebruik van lokale variabelen. Object variabelen woorden meestal ge-ïnitialiseerd in de methode init(). Het is ook zo dat object variabelen bij declaratie op 0 ge-ïnitialiseerd worden. Java 20

21 5.4 Regels voor opmaak van de code Om de leesbaarheid te bevorderen van een code is het geraadzaam zich volgende regels eigen te maken. 1. spring na iedere opening accolade een 3- tal spaties in 2. zorg dat de regels recht onder elkaar staan 3. na de afsluit accolade komt die voordien genomen spaties teug zodat alles gelijnd staat. 4. gebruik regelmatig een witregel 5. vergeet de bijhorende commentaren niet. Het is evident dat als je dit niet volgt je programma ook zal werken, gegeven dat je de juiste code gebruikt. Maar de leesbaarheid zal inboeten bij het niet gebruiken van deze regels. Dit kan zeer veel tijd vragen als je het programma wilt terug bestuderen, of als een ander het programma moet veranderen. E bestaan verschillende stijlen om een broncode te schrijven. Ik neem deze als gemakkelijk u kunt andere kiezen maar tracht steeds het zelfde idee te houden. Het helpt zelfs bij verbetering van de oefening. Java 21

22 Hoofdstuk 6 operatoren. 6.1 rekenkundige operatoren Optellen + Aftrekken - Vermenigvuldigen * Gehele deling / Rest na gehele deling % import java.awt.*; import java.awt.event.*; import java.applet.*; public class operatoren extends Applet { public void paint(graphics g){ int getal1=8, getal2=10, uitslag; // lokale variabelen g.drawstring("getal1= "+getal1+", getal2= "+getal2, 50,50); uitslag = getal1 + getal2; g.drawstring("de som is: "+ uitslag, 50, 70); uitslag = getal2 - getal1; g.drawstring("het verschil is: "+uitslag,50,90); uitslag = getal1 * getal2; g.drawstring("het product is: "+uitslag,50,110); uitslag = getal2/getal1; g.drawstring("het quotiënt is: "+uitslag,50,130); uitslag = getal2%getal1; g.drawstring("de rest is: "+uitslag,50,150); Figuur 10 Bovenstaand zijn alle rekenkundige operatoren welke ja gebruikt samen gevoegd. Figuur 10 geeft de uitkomst van het bovenstaande programma welke de werking van de operatoren uitlegt. Een punt dat we nader zullen bekijken is de gehele deling. De operator / duid aan hoeveel maal een gegeven getal in een ander getal gaat. De uitslag ervan is een geheel getal. Voorbeeld: 25/4 6 Java 22

23 10/8 1 1/2 0 De operator % geeft aan de andere kant de rest na de gehele deling: 25%4 1 10%8 2 1%2 1 Het gebruik van de rest na deling kunnen we het best illustreren et volgend programma: import java.awt.*; import java.awt.event.*; import java.applet.*; public class Deklok extends Applet { public void paint(graphics g){ int totaalmin = 1412, uur, restmin; uur = totaalmin /60; restmin = totaalmin % 60; g.drawstring("aantal minuten= "+totaalmin,53,30); g.drawstring("wordt "+uur+" en "+restmin+" minuten",50,60); Met dit programma rekenen we een tijdseenheid uit gebruikmakend van voorgaande Figuur De prioriteiten Zoals in alle berekeningen kan het gebeuren dat men prioritaire berekeningen heeft in een som. Ook in Java is de mogelijkheid van een berekening prioritair te stellen voor en andere. Voorbeeld y=ax+b dat wordt dan in Java y=a*x+b. In Java zijn de volgende prioriteitsregels van toepassing - de operatoren *, /, % hebben dezelfde prioriteit - de operatoren +, - hebben dezelfde prioriteit - *, /, % hebben een hogere prioriteit dan +, - - bij gelijke prioriteit zal de bewerking van links naar rechts gevoerd worden. 6.3 Uitvoer van getallen naar een tekstvak We weten dat men alleen wiskundige bewerkingen kan uitvoeren met gehele- of komma getallen. Daar tegenover staat dat de inhoud welke men gebruikt in een tekstvak van een ander type moet zijn, namelijk String. Java 23

24 Dat duid op een probleem. Daarom zijn er bepaalde commando s in Java die een type conversie verzorgen. Integer naar String String strgetal = String.valueOf(getal); String naar Integer Getal = Integer.parseInt(getal); Java 24

25 Hoofdstuk 7 Andere types 7.1 Type byte, long en short. Buiten het type int kent Java nog een 3 tal andere typen namelijk de byte, de long en het short type. Type Aantal bytes Bereik byte t/m 127 short t/m int 4 +/- -2miljard t/m +/- 2 miljard long 8 +/ -9*10 18 t/m 9*10 18 Soms is het nodig om verschillende van bovenstaande types door elkaar te gebruiken. Men kan zich afvragen: mag dat? In sommige gevallen wel en andere niet. 7.2 Impliciete conversie of promotie Een getal kan naar een hoger type klasse gepromoveerd worden. Dus byte, short, int mogen gebruikt worden als long. Vb: byte a = 10; short b = 32000; int c; c = a + b ; Dit is dus volstrekt mogelijk en zal ook regelmatig in een programma voorkomen. 7.3 Expliciete conversie Het andere geval zal maken dat de compiler fouten aangeeft. Men kan dus niet een type van een hoger bereik terug schroeven naar een lager bereik. Dus: int a=500, totaal; long b = 1000; totaal = a + b; Hier zal de compiler een fout aangeven. Immers men probeert een long type in een integer type te wringen, wat niet gaat. We hebben gezien dat de grote van een long 8 bytes is en dat van integer 4 bytes dus de compiler zal reclameren en een fout aangeven. Let wel dit is een veel voorkomende fout. Zou men schrijven: totaal = (int) a+b; dan zou het wel gaan. Dit omdat int tussen de haakjes de opdracht geeft om de som van beide getallen te converteren naar een integer. Dan is het probleem van de baan. Dit noemt men typecasting of kortweg cast. In een volgend voorbeeld komt men tot de zelfde conclusie: short a =100, b = 300, totaal Java 25

26 totaal = a+b terug geeft dit een fout. De reden is nu niet zo logisch. Hoewel alle variabelen van het type short zijn, zal dit een fout geven. De getallen a en b worden door impliciete conversie omgezet naar int types. Dus men heeft terug en cast nodig om deze som in een short variabele te krijgen. Dus totaal = (short) (a+b) is de oplossing. 7.4 Het suffix L Terug geven de Java compilers en foutmelding als je schrijft long getal = ; dit komt omdat de compiler re van uitgaat dat een geheel getal hoogstens van het type int is. Deze foutmelding kan je tegen gaan door een suffix L te gebruiken dat aanduid dat het een variabele is van het type long. Long getal L; zal dus geen fout meer genereren. Dit valt echter niet zoveel voor. Oefeningen: 1. Maak een analyse van en ontwerp een applet die uitrekent hoeveel minuten en seconden in en dag gaan. 2. Maak een analyse van en ontwerp een applet dat met behulp van 2 tekstvakken voor invoer en 5 knoppen, respectievelijk voor de +, -, *, /, en rest na deling. De verschillende bewerkingen worden uitgevoerd en getoond in een tekstvak voor uitvoer. De invoer mag enkel gehele getallen zijn. 7.5 Het type double. In vorige sessies hebben we het gedrag van het type integer of gehele getallen bestudeerd. In berekeningen zijn het echter niet steeds gehele getallen die aan bod komen. In de Engelse taal gebruikt men meestal de term floating point getallen als men gebroken getallen bedoelt. In Java heeft men twee primitieve typen voor het namelijk float en double. Beide hebben een verschillend bereik. Float heeft een bereik van 6 tot 7 cijfers en is daardoor, ondanks dat de lengte betrekkelijk groot is, niet zo nauwkeurig als double die een nauwkeurigheid heeft van 15 cijfers. Met float zal men gemakkelijker afrond fouten hebben. Om deze reden zullen we ons hoofdzakelijk bezig houden met double en het float een beetje links laten liggen. In variabelen van het type double kan men dus gebroken getallen in opbergen. In Java en ook in de meeste ander programmeer talen wordt het decimaal teken voorgesteld door een punt. Uit de wiskunde kent men de notatie, voor grote decimale getallen, met een exponent van 10. De zogenaamde wetenschappelijke notatie. In Java zal echter niet het getal 10 gebruikt worden maar e of E. Onderstaande tabel toont de bedoeling. Decimale notatie Met machten van 10 Notatie van Java x e x e x e -6 Java 26

27 7.6 Optellen van gebroken getallen import java.awt.*; import java.awt.event.*; import java.applet.*; public class gebrokengetallen extends Applet { double getal1, getal2, som; public void init(){ getal1 = 1000; getal2 = 2.3e3; som = getal1 + getal2; public void paint(graphics g){ g.drawstring("de som van getal 1 "+getal1+" en getal 2 "+getal2+ " geeft "+ som, 50,50); Figuur 12 Merk op dat de notatie in de code van getal 2 gedaan is op wetenschappelijke wijze, dus met een exponent notatie (getal2 = 2.3 e 3). Natuurlijk in onze uitkomst zal hij zoals alle ander getallen genoteerd worden. Immers het getal is niet te groot. 7.7 Operatoren voor floating point getallen. Hetzelfde als met het type int kunt u volgende operatoren in expressie met double gebruiken. Operator voor optellen +, Operator voor aftrekken -, Operator voor vermenigvuldigen *, Operator voor gehele deling /, Of operator % voor de rest van gehele deling. import java.awt.*; import java.awt.event.*; import java.applet.*; public class deling extends Applet { int getal1, getal2, iquotient; double getal3, dquotient1; double dquotient; Java 27

28 public void init(){ getal1 = 10; getal2 = 4; getal3 = 10.0; iquotient = getal1 / getal2; dquotient1 = getal1 / getal2; dquotient = getal3 / getal2; public void paint(graphics g){ g.drawstring("delen van gehele getallen met een gehele uitkomst " + iquotient, 50,50); g.drawstring("delen van gehele getallen met gebroken uitkomst " + dquotient1, 50,75); g.drawstring("delen van een gebroken getal met gebroken uitkomst " + dquotient,50,100); Figuur 13 Bovenstaande code geeft een beeld van de bewerking delen gedaan met de verschillende mogelijkheden. 7.8 cast Zoals we voordien gezien hebben, kunnen we ook hier een type casting uitvoeren. Herinnert u dat we dit deden om kleine onvolkomen heden te camoufleren. Neem nu dat we een 111 moeten verdelen in 4 dus: int getal = 111, verdeling = 4; double uitkomst; uitkomst = getal / verdeling; in dit geval zullen we 27.0uitkomen, en dit is een fout. Immers het moest zijn. Dit komt omdat men 2 gehele getallen deelt en de uitkomst gebroken is doet men aan type casting door double te vermelden voor de deling dan krijgt men wel uitkomst = (double) getal/verdeling 7.9 de waarde oneindig In tegenstelling tot de meeste andere programmeertalen kent Java oneindig als waarde Normaal is ons altijd geleerd in de wiskunde dat men niet kunnen delen door 0, andere wiskundigen beweren echter die 1.0/0.0 en -1.0/0.0 gelijk zijn aan oneindig en min oneindig. We gaan dit even onderzoeken met Java import java.awt.*; Java 28

29 import java.awt.event.*; import java.applet.*; public class oneindig extends Applet { double getal1, getal2, resultaat1, resultaat2; public void init(){ getal1 = 10.0; getal2 = -10.0; resultaat1 = getal1 / 0.0; resultaat2 = getal2 / 0.0; public void paint (Graphics g){ g.drawstring("+10.0 / 0.0 = "+resultaat1,50,50); g.drawstring("-10.0 / 0.0 = "+resultaat2,50,75); Figuur 14 Zoals we zien in de uitwerking van deze code zal Java de waarde oneindig (infinity), zowel positief als negatief kennen. Om extreem te gaan wat zou er gebeuren als we 0.0 delen door 0.0? We kunnen dit nakijken. Figuur 15 In dit geval krijgen we de aanduiding NaN wat de afkorting is van Not a Number. Dit is zeer interessant, als je in een programma dit tegenkomt dan weet je dat er ergens 0 door 0 gedeeld wordt toekenningsoperatoren In Java zoals in C wordt er gebruik gemaakt van toekenningsoperatoren. Uitdrukking, teller += 1, is in wezen het zelfde als teller = teller +1. Het is echter de verkorte schrijfwijze. Een ander voorbeeld: dikte += 3 kan gelezen worden als de dikte is toegenomen met 3 eenheden. Hetzelfde geld voor variabelen, snelheid += toename geeft dan de snelheid wordt verhoogd met de toename. Nog andere operatoren: Volledig geschreven Toekenningsoperator Som = som * 2 Som *= 2 Som = som / 2 Som /= 2 Som = som % 2 Som %=2 Alle bewerkingen komen dus in aanmerking voor de toekenningsoperatoren Een speciale soort echter is de increment en decrement operator. Deze herkennen we nog van de Pascal programmeertaal (inc en dec). De werking en het gebruik zijn natuurlijk hetzelfde. Increment teller++, en decrement teller Java 29

30 public class incredecre extends Applet { int op, neer; public void paint(graphics g){ op = 1; neer = 10; op++; neer--; g.drawstring("verhoging van op(1) door increment op++ geeft: "+op,50,50); g.drawstring("verlagen van neer door decrement neer--geeft: "+neer,50,70); Figuur 16 Zoals we zien uit ons programma hebben we door increment operator op 1 verhoogd, geinitialiseerd op 1 duid hij wel 2 aan. Hetzelfde voor de variabel neer, geinitialiseerd op 10 duid 9 aan. We zullen dit kunnen gebruiken als we werken met de verschillende soorten Loops in Java. Java 30

31 Hoofdstuk 8 Methoden 8.1 de methode repaint() import java.awt.*; import java.awt.event.*; import java.applet.*; public class label extends Applet { int klikteller; Button knop; Label label; public void init(){ klikteller =0; knop = new Button("klik"); label = new Label("000"); add(knop); add(label); public boolean action(event e, Object o){ if(e.target == knop){ klikteller++; String resultaat = String.valueOf(klikTeller); label.settext(resultaat); return true; return false; Deze code geeft een optelling van het aantal dat je klikt op de knop. De uitslag komt direct afgedrukt op de label. Figuur 17 Soms is het wenselijk dat we deze afdruk rechtstreeks op het canvas laten gebeuren. Volgende code zal daar voor zorgen import java.awt.*; import java.awt.event.*; import java.applet.*; public class canvas extends Applet { int klikteller; Button knop; public void init(){ klikteller = 0; knop = new Button("klik"); add(knop); Java 31

32 public void paint(graphics g){ g.drawstring(string.valueof(klikteller)+ "keer geklikt ",120,50); public boolean action(event e, Object o){ if(e.target ==knop){ klikteller++; return true; return false; Deze code werkt goed maar het enige probleem is dat de teller niet verhoogt, in feite wel maar u ziet de juiste uitslag niet. Dit gebeurt door dat het canvas niet veranderd en de eerste aanduiding op het canvas blijft bestaan. Daarvoor bestaat een mogelijkheid in Java opdat dit kan opgevangen worden. Door gebruik te maken van de methode repaint(). Wanneer zullen we repaint() gebruiken? Wel direct nadat de waarde van klikteller (de variabele waar de telling in bewaard wordt). Bekijken we eens de levens loop van deze applet: Event init() paint() action() repaint() Figuur 18 Op de figuur 18 zien we de levensloop van de applet waar we de methode repaint() ingevoegd hebben. Onderstaande code geeft de oplossing. Tracht eens de bovenstaande code af te leiden import java.awt.*; import java.awt.event.*; import java.applet.*; public class canvas extends Applet { int klikteller; Button knop; public void init(){ klikteller = 0; knop = new Button("klik"); add(knop); Java 32

33 public void paint(graphics g){ g.drawstring(string.valueof(klikteller)+ " keer geklikt ",120,50); public boolean action(event e, Object o){ if(e.target ==knop){ klikteller++; repaint(); return true; return false; Figuur 19 Na verhoging van de teller zullen we aan het programma vragen om het canvas te her tekenen. Dus zal het programma het canvas opkuisen en opnieuw tekenen. Daarom zal steeds het juiste getal getoond worden. Oefening: Maak eens een applet dat door druk op een knop een getal met 20 verhoogt. 8.2 Methoden In iedere objectgeoriënteerde taal spelen de methoden een grote rol. Dat is niet zo verwonderlijk want de methoden brengen de objecten tot leven. De meeste methoden worden aangetoond door gebruik te maken van de Java-klasse de String. Een String is geen normaal primitief type zoals we integer (int) en double kennen. Een String is dus in feite een object. De klasse String is, zoals de meeste bestaande klassen, voor gedefinieerd en worden standaard bij de Java-taal geleverd. Deze bestaat dus uit en aantal methoden die men op instanties van deze klasse kunnen toepassen. Andere klasse die ook een groot aantal methoden heeft is de klasse Math. Java 33

34 Hoofdstuk 9 String werking 9.1 String import java.awt.*; import java.awt.event.*; import java.applet.*; public class oef1 extends Applet { String zin; public void init(){ zin = "jantje zag eens pruimen hangen..."; public void paint(graphics g){ g.drawstring(zin,50,50); Figuur 20 Bovenstaande code geeft figuur 20 als uitkomst. Hier is zin en referentie naar een String. Een referentie moet ook evenals een variabele vooraf gedeclareerd worden: String zin. Nadien kan men de referentie naar een zeker String object laten verwijzen: zin = jantje. Nu kunt u zich afvragen waarom gebruikt men ook niet de new verwijzing zoals bij ander objecten? Dit is echter niet nodig, men mag het wel maar de vorige versie is korter en daarom wordt deze gebruikt. 9.2 concatenatie van Strings import java.awt.*; import java.awt.event.*; import java.applet.*; public class oef1_1 extends Applet { String zin1, zin2; public void init(){ zin1 = "jantje zag eens pruimen hangen,"; zin2 = "o, als eieren zo groot"; public void paint(graphics g){ g.drawstring(zin1 + zin2,50,50); Java 34

35 Figuur 21 Men kan twee String objecten gewoon samen voegen door gebruik van het + teken. Men moet wel letten op de uiteindelijke lay-out. 9.3 lege String Soms is het ook handig om een lege String object aan te maken. Dit is soms handig bij bewerkingen van String om spaties te voorzien. Deze worden dan als volgt gedeclareerd: String spatie =. 9.4 concatenatie van String en getallen. Als men het volgende zou declareren: String straat= open weg + 52 zal bij uitwerking worden open weg 52. het getal zal gewoon achter het woord of String geplakt worden. Er kunnen echter eigenaardigheden opduiken. Probeer eens de volgende code: import java.awt.*; import java.awt.event.*; import java.applet.*; public class oef3 extends Applet { String zin1, zin2; double getal1, getal2; public void init(){ getal1 = 2.50; getal2 = 13.10; zin1 = getal1+getal2+" is de som van de getallen"; zin2 = "de som van de getallen is"+getal1+getal2; public void paint(graphics g){ g.drawstring(zin1, 50,50); g.drawstring(zin2,50,70); Wat bemerk aan de uitwerking van deze code? U zult zien dat de zin 1 de som van de getallen zal geven, maar zin twee enkel de concatenatie van de zinnen. Daarop zal men wel moeten letten als men een code samenstelt. Hoe kan men dat nu voorkomen. De eerste manier is werken met haakjes. Als men getal1+ getal2 tussen haakjes plaatst( hebben we met de werking van de haakjes), eerst de bewerking voor we de zin schrijven en bekomen we de juiste uitslag. Probeer maar eens. Met de tweede manier zullen we eerst de som uitrekenen en dan laten afdrukken. Beide manieren zijn goed. Men zal zelf moeten uitmaken welke maner we zullen gebruiken. Java 35

36 9.5 Integer omvormen naar een String Veelal is het nodig dat we een Integer getal eerst moeten omvormen naar een String voor we het kunnen behandelen in een ander object. Denk maar aan een tekstbox, daar is de inbreng steeds van het type String. import java.awt.*; import java.awt.event.*; import java.applet.*; public class oef4 extends Applet { TextField vak; String zin, woord; int getal; public void init(){ vak = new TextField(10); getal = 15; zin = "jaar oud "; woord = String.valueOf(15); add(vak); vak.settext(woord+zin); public void paint(graphics g){ g.drawstring(woord+zin,50,50); Figuur 22 Bovenstaande code laat zien dat we gemakkelijk een Integer kunnen omvormen in een String variabele, om te gebruiken in een tekst veld. Dit kan handig zijn in de oefeningen. 9.6 methoden van een String Java 36

37 Java 37

38 Oefeningen: 1.Maak een applet waar men door een druk op een knop de volgende woorden omzet naar woorden met een hoofdletter. Gebruik daarvoor liefst de methoden van de klasse. drinken moet men doen voor de gezondheid. 2.Maak door concatenatie ook een zin daarvan en voeg toe: dat moet niet altijd water zijn. Deze laatste zin moet onafhankelijk kunnen bestaan.(variabele?). 3.Maak een applet waar men 2 tekstvakken heeft, waar men twee teksten in plaatst. Door een druk op een knop moet men op in een ander tekstvak de teksten samen voegen. 4. Bereken in een applet de lengte van de zin uit oefening 2. Laat dit getal in een tekstvak verschijnen. Java 38

39 Hoofdstuk 10 Klassen We gaan ons in dit deel verdiepen in het zelf maken van klassen. We hebben hiervoor steeds klassen gebruikt die in de uitgebreide kassen bibliotheek van Java zaten. Door echter het zelf definiëren van klassen, kunnen we dit programma uitbreiden en aanpassen aan onze eigen behoeften zelf klassen maken Nemen we als voorbeeld een klasse die onze rekening bij de bank moet bijhouden. Bij ieder bankrekeningen zijn er bepaalde zaken die typisch zijn: naam, bankrekening het bestaande saldo (of krediet). In dit geval zullen we geen rekening houden met het bankrekeningnummer. Dit zou ons en beetje te ver brengen. Let wel we kunnen dat eventueel in latere stadia wel bij voegen. Laten we eens een analyse van de klasse bekijken: Rekening String naam double saldo Figuur 23 In figuur 23 ziet u de beschouwelijke voorstelling van de klasse. De naam bestaat uit Rekening, en de variabelen zijn naam en saldo. In Java schrijven we: Class Rekening{ String naam; Double saldo; Class is een gereserveerd word in Java. De naam ervan is vrij te kiezen verstandig is echter om een naam te kiezen dier ergens verwijst naar de functie van de klasse. Dit om moeilijkheden te vermijden. We nemen ook aan dat de naam van een klasse in met een hoofdletter begint. We weten dat Java case sensitive is. We kunnen de naam dus ook gebruiken om en object re mee benoemen, maar dan met een kleine letter. Het kan handig zijn om het verschil er van op te merken. Tussen de accolades staan de referenties van de klasse. In dit geval een referentie naam met als type String en een referentie saldo met als type double. De referenties die we declareren in een klasse noemen we dan ook attributen van die klasse wat kunnen we nu doen met die klassen? Java 39

40 Na het definiëren van een klasse zullen we er ook mee trachten te werken. Met dit bedoelen we in object georiënteerde taal het maken van objecten. Om objecten te herkenen moeten we ze eerst koppelen aan een naam. Dit declareren doen we dus: Rekening a, b; Door dit declareren hebben we echter nog geen object. Uit vorige lessen weten we dat we daarvoor het woord new nodig hebben. Dus: a = new rekening(); b = new rekening(); nota: Java levert bij ieder klasse een constructor methode waar we objecten kunnen mee maken. Over de constructor gaan we later nog verder spreken maar deze heeft de naam van de klasse en maakt het mogelijk van objecten te ontwerpen. Om een nieuwe klasse te maken zijn er dus in principe 3 stappen nodig nl.: - definiëren van de klasse - declareren van de referenties - nieuwe objecten maken vb. import java.awt.*; import java.awt.event.*; import java.applet.*; class Rekening{ String naam; double saldo; public class oefning1 extends Applet { Rekening a, b; public void init(){ a = new Rekening(); b = new Rekening(); a.naam = " Jansens"; a.saldo= 100; b.naam = " Pieters"; b.saldo = 120; public void paint(graphics g){ g.drawstring(" het saldo van persoon "+a.naam+" is "+a.saldo,50,50); g.drawstring(" het saldo van persoon "+b.naam+" is "+b.saldo,50,70); Figuur 24 Java 40

41 Figuur 24 geeft de uitwerking van de bovenstaande oefening methoden in een klasse De bovenstaande klasse is echter maar een mager iets. Buiten de naam en saldo kunnen we niet veel aanvangen met deze klasse. We gaan de functionaliteit van de klasse een beetje verhogen en wel door het invoegen van een methode. Het zou handig zijn dat deze methode, buiten het maken van objecten voor naam en saldo, deze ook laat zien op het canvas. Daarvoor gaan we een methode inbouwen in onze klasse. Laten we deze zien() noemen. Daardoor zal onze klasse 3 members (leden) hebben, 2 attributen en 1 methode. Aanschouwelijk is dat dan: Rekening String naam double saldo void zien(graphics g, int x, int y) Figuur 25 Merk op dat we deze methode beginnen met void. Met andere woorden deze methode zal niets terug geven. Laten we ons voorbeeld even aanpassen: import java.awt.*; import java.awt.event.*; import java.applet.*; class Rekening{ String naam; double saldo; void zien(graphics g, int x, int y){ g.drawstring("saldo van " + this.naam + " is " + this.saldo, x,y); public class oefning1 extends Applet { Rekening a, b; public void init(){ a = new Rekening(); b = new Rekening(); a.naam = " Jansens"; Java 41

42 a.saldo= 100; b.naam = " Pieters"; b.saldo = 120; public void paint(graphics g){ a.zien(g,50,50); b.zien(g,50,75); Figuur 26 In bovenstaande figuur zien we de nieuwe uitwerking van ons voorbeeld. Men kan zien dat de methode paint er een gans stuk eenvoudiger op geworden is. In de laatste versie zien we dat we door de methode zien we een sein sturen naar het object dat ons de tekst laat zien. De werking ervan is redelijk goed te verstaan. In de klasse maken we een methode zien die de ingebouwde methode Graphics aanspreekt. Zoals we weten heeft deze methode argumenten nodig, nl.: g, x, y. Bij het versturen van het bericht zien(g,50,50) zenden we actuele argumenten. Deze argumenten nemen de plaats in van de formele argumenten in de methode, Zodat uiteindelijk int x,50 wordt en int y ook 50 voor het object a. Het is inderdaad een beetje koffie dik kijken maar gaandeweg wordt dat wel duidelijk. We hebben nu nog het gereserveerde woord this. This is en automatische referentie naar het object waar naar het bericht gezonden wordt. In dit geval betekend dit: Bij uitvoering van bijvoorbeeld a.zien(g,50,75); Na dit commando wordt er een bericht gezonden naar het object b en dit geeft; void zien(graphics g, int x, int y){ g.drawstring( Saldo van + this.naam is + this.saldo, x, y) ; In feite is de referentie van deze methode naar het object b. dus, deze betekent dat b.naam en b.saldo aan gesproken wordt Ontwerp van een klasse Laten we eens een klasse ontwerpen waarmede we een rechthoek tekenen, dus een klasse rechthoek. Hoe word die ontworpen? Dit is een belangrijke vraag bij elke klasse die men ontwerpt in een object oriented taal. We kunnen bijvoorbeeld in dit geval de vraag splitsen in twee deelvragen, nl. - W at is bij iedere rechthoek identiek? - Waarin verschillen iedere rechthoeken van elkaar? Twee ogenschijnlijk simpele vragen maar, het antwoord op de tweede vraag leggen de attributen vast en het antwoord op de eerste vraag zal de methoden vast leggen De attributen Java 42

43 In vorig punt hebben we zogoed mogelijk trachten te antwoorden op de gestelde vragen en hebben bemerkt hoogte en breedte de attributen van de klasse zullen zijn. Verder is het absoluut mogelijk dat we twee rechthoeken op twee verschillende plaatsen op het scherm kunnen zetten. Zodanig dat we de plaats op het canvas dus ook als attribuut kunnen aannemen. Om dit te bepalen kunnen we bijvoorbeeld de linkerbovenhoek coördinaten nemen. We noemen dit links en boven zijnde de x en y coördinaten van de rechthoek. Aanschouwelijk wordt dat dan: Rechthoek int links int boven int breedte int lengte Figuur 27 Het zou ook handig zijn als we een methode maken, met welke we de attributen een waarde zouden geven. Deze methode noemen we een setter of een set methode. In ons geval kunnen we hem bijvoorbeeld geefwaarden noemen. Het nieuwe voorbeeld zou dan zijn: Rechthoek int links int boven int breedte int lengte Figuur 28 void geefwaarden(int links, int boven, int breedte, int hoogte Let wel de methode die de set waarden geeft, de setter, is void. Nu zitten we nog meteen groter probleem. nl.: de computer moet nu verstaan dat we met links de linkerhoek van het object bedoelen. We weten dat een computer in feite maar een machine is en dus niet over een logisch denkvermogen bezit, zoals de meeste van ons. Daarom moet men expliciet zeggen over wat we spreken. Gelukkig hebben we nu de referentie this. We hebben al in vorige uiteenzettingen gezien wat de referentie betekend. Daarom wordt: Java 43

44 void geefwaarden(int links, int boven, int breedte, int hoogte){ links = links; boven = boven; breedte = breedte; hoogte = hoogte; In ons geval dan: void geefwaarden(int links, int boven, int breedte, int hoogte){ this.links = links; this.boven = boven; this.breedte = breedte; this.hoogte = hoogte; In dit geval is this.links de naam van het attribuut en links de naam van het argument. In dit geval zullen de waarden aan het argument worden gekoppeld. Terug het lijkt allemaal ingewikkeld maar na een paar oefeningen gaat u zien het gaat vanzelf. Lat ons nu bij wijze van voorbeeld even twee rechthoeken met deze methode tekenen. import java.awt.*; import java.awt.event.*; import java.applet.*; public class oefrechthoek extends Applet { Rechthoek a, b; public void init(){ a = new Rechthoek(); b = new Rechthoek(); a.geefwaarden(50,50,100,75); b.geefwaarden(75,75,150,100); public void paint(graphics v){ v.setcolor(color.cyan); a.teken(v); v.setcolor(color.green); b.teken(v); class Rechthoek{ int links; int boven; int breedte; int hoogte; void teken(graphics g){ g.drawrect(this.links, this.boven, this.breedte, this.hoogte); void geefwaarden(int links, int boven, int breedte, int hoogte){ this.links = links; this.boven = boven; this.breedte = breedte; this.hoogte = hoogte; Java 44

45 Maak eens dit voorbeeld en u zult bemerken dat u twee rechthoeken getekend hebt. Met gemak kunt u nog een rechthoek bij tekenen, bij voorbeeld met coördinaten 100,100 en de afmetingen, 125,75. Probeer maar eens en u zult de nood van klassen bemerken. We kunnen dat in feite vergelijken met procedures in Pascal, hoewel de gelijkenis ver gezocht is. Merk ook op dat de plaats van de bijkomende klasse van geen belang is. Handig in dit geval is wel als we onze klassen zouden kunnen verbeteren of meer functioneel maken. Dat kan als we methoden zouden bijvoegen in onze klassen. We hebben vroeger eens iets geprogrammeerd waar een rechthoek 90 gedraaid moest zijn. Hetzelfde gaan we nu met klassen programmeren: public class draairechthoek3 extends Applet { Rechthoek a; public void init(){ a = new Rechthoek(); a.geefwaarden(100,100,120,60); public void paint(graphics g){ g.setcolor(color.blue); a.schrijf(g); a.draai(); g.setcolor(color.green); a.schrijf(g); class Rechthoek{ int links; int boven; int breedte; int hoogte; void schrijf(graphics g){ g.drawrect(this.links,this.boven,this.breedte, this.hoogte); void geefwaarden(int links, int boven, int breedte, int hoogte){ this.links = links; this.boven = boven; this.breedte = breedte; this.hoogte = hoogte; void draai(){ int kopiehoogte = this.hoogte; this.hoogte = this.breedte; this.breedte = kopiehoogte; Java 45

46 Deze code zou moeten hetzelfde geven. Tik deze code in en u zult bemerken dat het inderdaad terug hetzelfde is, maar met minder code (in zo een kleine oefening is dat niet merkbaar). Maar de rechthoek is en blijft steeds dezelfde, zonder dat je speciale berekeningen moet maken. Veranderd met de setter heeft men ook direct een andere rechthoek. Een kleine bemerking over een variabele welke we gebruikt hebben, namelijk de variabele kniehoogte. U bemerkt dat hij enkel in die methode van belang is en verder niet meer. Daarom noemen we dit ook een lokale variabele. Zijn leven is dan ook beperkt tot het gebruik in deze methode Methoden Zoals al voordien opgemerkt zijn de methoden een belangrijk onderdeel van de klassen. Er bestaan natuurlijk soorten methoden, zoals we in de vorige taal die we bestudeerd hebben, Pascal, verschillende soorten functies hadden. We zullen er hieronder een soort van bespreken, nl. deze die iets terug geeft aan het programma Methode die een waarde terug geeft. import java.awt.*; import java.awt.event.*; import java.applet.*; class Rechthoek{ int links; int boven; int breedte; int hoogte; void teken(graphics g){ g.drawrect(this.links, this.boven,this.breedte, this.hoogte); void geefwaarden(int links, int boven, int breedte, int hoogte){ this.links = links; this.boven = boven; this.breedte = breedte; this.hoogte = hoogte; int oppervlakte(){ return this.breedte * this.hoogte; public class terug extends Applet { Rechthoek a; public void init(){ a = new Rechthoek(); a.geefwaarden(100,100,150,75); Java 46

47 public void paint(graphics g){ a.teken(g); int opp = a.oppervlakte(); g.drawstring(" de oppervlakte is: "+opp,100,270); Figuur 29 Hier boven staat een methode die iets terug geeft namelijk een integer, de oppervlakte van de rechthoek. Het gaat in zijn werk als volgt: In de methode maken we en berekening. De waarde van de berekening wijze we toe aan een lokale variabele van deze methode. Hier echter moeten we er wel op wijzen dat we bepaalde variabelen niet expliciet aangeven. Vb. int oppervlakte(){ int opp opp = this.breedte*this.hoogte; => int oppervlakte (){ return this.breedte*this.hoogte; return opp; U ziet in bovenstaande code dat we bepaalde stappen over slaan, en de locale variabele opp direct vervangen door zijn inhoud. Het is een verkorte schrijfwijze maar het heeft hetzelfde effect. Natuurlijk bij ingewikkelde berekeningen ben je beter de scheiding behouden. Door tussen resultaten opbergen in lokale variabelen. Nadien kunnen we deze methode in het hoofd programma gebruiken. Int opp = a.oppervlakte(); Terug vindt je hier de verwijzing naar de figuur door de figuur er in te betrekken, a.oppervlakte De methode zal een integer terug geven die gelijk is aan de oppervlakte van het naar verwezen rechthoek. Maakt men nog een andere rechthoek met andere waarden kan men terug van de zelfde methode gebruik maken om de oppervlakte te berekenen. Java 47

48 10.7enkele richtlijnen voor het schrijven van methodes - Bedenk wat je met de methode wil bereiken en probeer dat in gewoon Nederlands te omschrijven. Dat is belangrijk! Immers lukt dat niet dan zal het in Java ook niet lukken - Geef de methode een naam die aanduidt wat hij moet uitvoeren. Ingewikkelde naamgeving is ook hier uit den boze - Maak de methode zo flexibel mogelijk. Daardoor kan men hem in meer dan één situatie gebruiken. - Bedenk als de methode een waarde moet afgeven die in verdere berekeningen moet gebruikt worden. Als het GEEN terugkeer waarde is maak er een void van. - Als je in een klasse een methode definieert kan deze in ander methoden van dezelfde klasse gebruikt worden. Oefeningen: 1. Probeer vorige oefening waar je een cirkel verkleinde en verplaatste deze zaken onder te brengen in klassen. Vergeet de methode niet om de oppervlakte te berekenen 2. Maak een programma Rekening (zie voorbeeld) waar men buiten de naam en saldo ook nog klanten kan bij voegen en de berekend welke het totaal bedrag van de saldo s is. 3. als vervolg maak je een applet die gebruikmakend van vorige oefening de mogelijkheid heeft om via tekstvakken bedragen te storten en op te nemen van een bepaalde rekening Java 48

49 Hoofdstuk 11 Keuzen, lussen en herhalingen In het aspect keuzes hebben we zoals in ieder programmeertaal kunnen we ook in Java onderscheid maken tussen enkelvoudige en meervoudige keuzes. Deze worden verkregen door enerzijds de if structuur en anderzijds de case structuur De if structuur We hebben deze structuur al gebruikt, maar in beperkte mate en toen we spraken van events. Hierna zullen we het ook als een keuze optie kunnen gebruiken. public class Keuze1 extends Applet { TextField getal1, getal2; int cijfer1, cijfer2, cijfer3; String s1,s2; public void init(){ getal1 = new TextField("10"); getal2 = new TextField("20"); add(getal1); add (getal2); cijfer1= Integer.parseInt(getal1.getText()); cijfer2= Integer.parseInt(getal2.getText()); if(cijfer1 > cijfer2){ cijfer3 = cijfer1; else{ cijfer3 = cijfer2; public void paint(graphics g){ g.drawstring(" de grootste is "+cijfer3, 50,100); Figuur 30 Bovenstaande code is een voorbeeld van de if structuur. Daarin zien we de syntax van de if structuur: if(conditie){ Bewerking else{ Bewerking Java 49

50 Bemerk de accolades na de statements. Deze beginnen en sluiten de bewerking af die bepaald wordt door de conditie. Anders dan in de taal Pascal is dat; mag na de else tak staan. De rest is bijna hetzelfde. De conditie moet terug van het booleaanse type zijn. D.w.z. : teken bedoeling < Kleiner dan > Groter dan == Gelijk aan <= Kleiner dan of gelijk aan >= Groter dan of gelijk aan!= Is niet gelijk aan Tevens hebben we ook de logische operatoren en, of; deze om samengestelde condities te maken: en = && en of = Switch Het grote nadeel van de if functie is zeker de beperkte mogelijkheden. Dat wil zeggen: als men meerdere keuzes moet maken we een onoverzichtelijk kluwen kan hebben van if functies. In de taal programmeertaal Pascal hebben we dat probleem ook aangekaart. Daarvoor hadden we de Case structuur. Dit bestaat ook in de programmeertaal Java, weliswaar onder een andere naam. Hier noemt dat het switch statement. Een klein voorbeeld zal ons wel duidelijker zijn. public class keuze3 extends Applet { TextField vak1; int cijfer; String tekst; public void init(){ vak1 = new TextField("3");add(vak1); cijfer = Integer.parseInt(vak1.getText()); switch(cijfer){ case 5: tekst = "vijf"; break; case 4: tekst = "vier"; break; case 3: tekst = "drie"; break; case 2: tekst = "twee"; break; default: tekst = "het getal is te klein"; public void paint(graphics g){ g.drawstring("geef een getal tussen 1 en 5",10,10); g.drawstring("het getal is "+tekst,10,100); Java 50

51 Figuur 31 De switch expressie begint steeds met een accolade en sluit af met en accolade. De switch expressie kan van het type int, char, byte of short zijn. In de praktijk zal men meestal int en char bereiken. De types long, double of float zijn niet toegelaten. Belangrijk is wel de uitdrukking break na ieder case stelling. Plaatst men dit niet zal de overige commando s ook uitgevoerd worden.(probeer maar eens). Later gaan we deze wel meer gebruiken in andere statements. Oefening 1. maak een applet die de lengte van een 5-tal personen in categorieën indeelt. de lengten zijn 1.80, 1.70, 1.75, 1.30 en1.60 meter. De verdeling gebeurt: 1.60m te klein, 1.70 en 1.75 goed, 1.80 te groot. Alle andere krijgen als mededeling niet goed. Men kan dit oplossen met 2 methoden. Probeer beide eens te maken. 2. maak een applet welke oppervlakten van een rechthoek met elkaar vergelijkt. De oppervlakten van de rechthoeken worden gemaakt met behulp van klassen die men ontwerpt. Let wel één van de methoden moet de oppervlakte berekenen. Men moet de lengte en de breedte van de rechthoek kunnen ingeven. 3. maak een programma dat een applet construeert welke een cirkel voorstelt. Een methode geeft de oppervlakte en de ontrek van een cirkel bij het ingeven, langs een tekstvak, van de straal. Tevens moet de diameter aan gegeven worden. De waarden verschijnen in een label op het canvas. Java 51

52 11.3 String vergelijkingen. Zoals de programmeertaal C en nog een paar anderen is de taal Java niet een taal die zich hoofdzakelijk bezig houdt met manipuleren van String. Dit in tegen stelling met de talen Pascal, Cobol en nog een paar anderen. Wanneer zijn 2 String gelijk? Dit is een vraag die in Java niet zo gemakkelijk is om op te lossen. Logischer wijze kunnen we stellen: public class zinnen extends Applet { int a = 3; int b = 4; int c = a + b; String s = "Ja"; String t = "va"; String u = s + t; public void paint(graphics g){ if (c == 7) { g.drawstring("ze zijn gelijk", 10, 20); else { g.drawstring("ze zijn niet gelijk", 10, 20); if (u == "Java"){ g.drawstring("ze zijn gelijk", 10, 40); else{ g.drawstring("ze zijn niet gelijk", 10, 40); Figuur 32 In bovenstaand programma zien we dat de eerste bewering opgaat maar de bewering met de String niet. Ze zijn echter gelijk, hoe kan dat dan? Wel het antwoord ligt hem hierin dat de operator = = werkt voor primitieve anders dan voor objecten. Zoals we weten is een String een object, bij het vergelijken van primitieve typen gaan we de inhoud van de variabele controleren. Bij objecten echter is dit niet het geval, hier gaan we kijken naar de referentie van het object. Deze zijn natuurlijk niet hetzelfde zodat onze operator is gelijk aan een vals afgeeft. Voor dit te voorkomen hebben we een ander commando. Geen operator maar een methode uit de klasse String namelijk equals(). Dit geeft: Java 52

53 public class zinnen extends Applet { int a = 3; int b = 4; int c = a + b; String s = "Ja"; String t = "va"; String u = s + t; public void paint(graphics g){ if (c == 7) { g.drawstring("ze zijn gelijk", 10, 20); else { g.drawstring("ze zijn niet gelijk", 10, 20); if (u.equals("java")){ g.drawstring("ze zijn gelijk", 10, 40); else{ g.drawstring("ze zijn niet gelijk", 10, 40); Figuur 33 In dit geval toont figuur 33, dat beiden gelijk zijn, wat de bedoeling was. Nu hebben we nog het probleem van het al dan niet gebruik van hoofdletters of kleine letters. Wel we weten dat in de ASCII tabel er een verschil bestaat tussen hoofd- en kleine letters. Dit kan opgevangen worden in Java door een uitbreiding aan bovenstaande methode. Bekijk eens onderstaand voorbeeld. public class zinnen extends Applet { String s = "Ja"; String w = "ja"; String t = "va"; String u = s + t; String x = w + t; public void paint(graphics g){ if (x.equals("java")) { g.drawstring("ze zijn gelijk", 10, 20); else { g.drawstring("ze zijn niet gelijk", 10, 20); if (u.equals("java")){ g.drawstring("ze zijn gelijk", 10, 40); Java 53

54 else{ g.drawstring("ze zijn niet gelijk", 10, 40); Figuur 34 Gebruiken we echter de methode x.equalsignorecase() zal dit probleem ook opgelost zijn. Probeermaar eens Herhalingen for statement. Indien we beginnen met herhalingen gaan we steeds beginnen met de meest voorkomende, de for- statement public class Herhalingen extends Applet { public void paint(graphics g){ int a; for(a = 1; a <= 5; a++){ g.drawline(50,25,180,a*20); Figuur 35 Bovenstaande code geeft de werking van het for statement aan. Laten we dit even dieper bekijken. Het belangrijkste is het controle gedeelte. Dit gedeelte, direct geschreven na de for, bestaat uit 3 delen. Laten we deze even bekijken - a = 1 Hier in stellen we een, eventueel vooraf gedeclareerde variabele, gelijk aan 1. Let wel ik stel hier dat deze variabele niet noodzakelijk vooraf gedeclareerd hoeft te zijn. Meestal zal men de for constructie als volgt initiëren: for(int a = 1 ). In dit geval heeft men geen vooraf gedeclareerde variabele nodig. - a<=5 Hiermede zullen we de waarde van de stuurvariabele, in dit geval a, beperken tot een zekere grootte. Deze is afhankelijk aan de werking van het programma. We zullen de bekende booleaanse vergelijkingen daarvoor gebruiken. - a++ In de programmeertaal Pascal hebben we gezien dat de for lus automatisch van waarde verhoogt. Bij de talen zoals c en Java moet men zelf zorgen voor de ophoging van de stuurvariabele. Met de operator a++ is dat zeer voordelig Java 54

55 opgelost. Let wel als we de verhoging per 2 of meerdere eenheden zouden willen moet men hier de verhogingsfactor veranderen. Na deze commando s plaatsen we een open accolade, waarna we de nodige commando s die tijdens de herhaling moeten worden uitgevoerd, plaatsen. Alles wordt dan afgesloten door een sluit accolade. Visueel voorgesteld met gebruik makend van de Nassi Sneiderman methode: Voor int a = 1 --> 5 g.drawline(50,25,180,a*20); Figuur 36 Dus als a = 1 dan zal men het commando g.drawline(50,25,180,a*20); uitvoeren, daarna zal de stuurvariabele met 1 verhoogd worden (a++) en terug het commando uitvoeren. Dit zolang dat de stuurvariabele kleiner is dan of niet gelijk is aan 5. Principieel is er terug geen verandering met de for commando s die we kennen. We moeten wel letten op een paar eigenaardigheden: - plaats geen punt komma na het controle gedeelte - men kan de stuurvariabele declareren in de stuurlus - het verhogen, of verlagen van de stuurvariabele doet men met de gekende operatoren Animatie Een leuk gevolg van het for statement is dat mendoor oordeelkundig gebruik ervan een soort animatie kunnen programmeren. Wel rudimentair maar toch. Een animatie is en bewegend voorwerp op het scherm. Het systeem is logisch: 1. men tekent een object op het scherm op een bepaalde positie. 2. men wacht een bepaalde tijd 3. laat het object verdwijnen 4. tekent het object op een ander plaats. Gezien we dit kunnen zien als een herhaling gedurende een bepaalde lengte kunnen we deze in een lus plaatsen. Nemen we bijvoorbeeld een vallende bal. Wetende dat we deze bal steeds moeten opnieuw tekenen is het handig als we een klasse maken van die bal import java.awt.*; Java 55

56 import java.awt.event.*; import java.applet.*; class Val{ private int links; private int boven; private int straal; private int straal1; private Color kleur; // constructor Val(int Links, int boven, int straal, int straal1, Color kleur){ this.links = links; this.boven = boven; this.straal = straal; this.straal = straal; this.kleur = kleur; void teken(graphics g){ g.setcolor(this.kleur); g.drawoval(this.links, this.boven, this.straal, this.straal); void naarbeneden(){ this.boven++; void teken(graphics g, Color kleur){ g.setcolor(kleur); g.drawoval(this.links, this.boven, this.straal, this.straal); public class bal extends Applet { Val bol; public void init(){ bol = new Val(30,30,20,20,Color.red ); void slaap(int milisec){ try{thread.sleep(milisec); catch (InterruptedException e){ public void paint(graphics g){ Color achtergrond = getbackground(); for(int i = 0; i<190;i++){ bol.teken(g); slaap(10); bol.teken(g,achtergrond); bol.naarbeneden() ; bol.teken(g); Java 56

57 Deze code zal een bal van boven aan het scherm naar beneden laten vallen. We zien hier twee methoden dat we niet kennen maar welke we in de toekomst nog gaan gebruiken. Namelijk de methoden getbackground() en Sleep(). Deze zullen we hierna bespreken. Laat ons eerst even de code bekijken: In een aparte klasse zullen we onze bol maken. Daarvoor gebruiken we ook een constructor. Zoals we vroeger gezien hebben zal deze klasse over verschillende methoden bestaan. Waarom we een klasse gebruiken zal nogal wiedes zijn. Immers we moeten steeds die bol her tekenen, vandaar. De constructor maakt het mogelijk dat we de bol kunnen gebruiken. De methoden die de beweging veroorzaken staan ook in de klasse gedeclareerd. In onze voorbeschouwing, hebben we de methode bekeken. Daarin hebben we benadrukt dat we na het teken en wachten, we de bol moeten uitvegen. Een gemakkelijke methode is gewoon de bestaande achtergrond terug te plaatsen en zo de tekening te verdoezelen, of dus weg te vegen. Het wachten echter is een ander paar mouwen. Daarvoor zullen we een bestaande methode in Java gebruiken, namelijk de sleep methode. Dit is een methode uit de klasse Thread. Een thread of draad is een uitvoering van het programma. JVM (Java Virtual Machine), geeft de mogelijkheid om verschillende draden van uitvoering tegelijkertijd te laten gebeuren. Ieder uitvoering heeft zijn prioriteit in het programma. Verder in de cursus zullen we daar nog uitvoerig over terugkomen. In dit geval gebruiken we een methode van de klasse namelijk de sleep methode. Met deze methode zullen we het programma stopleggen. De tijd, ingegeven als argument van deze methode geeft aan, in milliseconden, hoelang we zullen vragen dat het programma stil ligt. Na verloop van de tijd zal het programma terug opstarten. Steeds laten we deze methode voorafgaan door het gereserveerde woord try. Nadien als het thread terug opstart zal hij een true zenden naar een InterruptedException. Deze zal dan zorgen dat de JVM terug opstart. Dit zullen we bekomen door het gereserveerde woord catch(). Tussen de haakjes zetten we De instantie InterruptedException. Over Exceptions zullen we later verder uitbreiden als we fouten gaan opvangen. Oefeningen: 1. maak een applet welke de vermenigvuldiging tafels van 1 tot 9 opstelt. Men dient een aparte klasse te gebruiken om deze in te stellen. 2. schrijf in bovenstaande oefening een methode die de tafel van 13 laat verschijnen: de vorm moet zijn: 1x 13 = 13 2x 13 = x 13 = Maak van het programma met de 'vallende bal', dat er 3 ballen neder vallen op een verschillend tijdstip. 4. Maak een applet die de rij van Fibonaci voorstelt ( 1, 1, 2, 3, 5 ). 5. Maak een applet dat een bepaalde spaar rekening voor stelt en die de rente uitbrekend voor een tegoed van 1000 over de looptijd van 5 jaar Java 57

58 Hoofdstuk 12 Controle van de invoer Veelal is het aangewezen dat we een controle uitvoeren op een bepaald gegeven dat we invoeren, hetzij langs het toetsenbord, hetzij langs andere mogelijkheden (bestanden, scanners.). Daarvoor bestaan er meerdere mogelijkheden. Verder in dit hoofdstuk gaan we ook zien hoe we een gemaakte fout kunnen opvangen simpele controle van de invoer import java.awt.*; import java.awt.event.*; import java.applet.*; public class fouten extends Applet { private int getal1, getal2,getal3; private Button knop; private TextField in1,in2, som; public void init(){ in1 = new TextField(5); in2 = new TextField (5); som = new TextField(10); knop = new Button("tel"); add(in1);add(in2);add(som);add(knop); public void berekening(){ String tekst; getal1 = Integer.parseInt(in1.getText()); getal2 = Integer.parseInt(in2.getText()); if(getal1 <= 1 getal2 >10){ tekst="foutief getal"; som.settext(tekst); in1.settext(""); in2.settext(""); else{ getal3=getal1+getal2; som.settext(string.valueof(getal3)); public boolean action (Event e, Object o){ if(e.target == knop){ berekening(); return true; return false; Java 58

59 Bovenstaand voorbeeld is een uitvoer van een simpele controle van de invoer. Met dit systeem zullen we, gebruikmakend van de simpele booleaanse vergelijkingen, de ingang op zijn waarde controleren. We kunnen ook gebruik maken van de OR en de AND om bepaalde verbinding in de controle te maken. In vroegere lessen hebben we de OR en AND diepgaand besproken. Het is vanzelfsprekend dat we deze eigenschappen hier ook kunnen gebruiken. Merk wel op dat de schrijfwijze, zoals ook in het begin vermeld enigszins afwijkt. OR = en AND = && Berekeningen in de paint methode In voeger oefeningen werd er veelal gebruik gemaakt van de paint methode om bepaalde berekeningen uit te voeren. Als men een getal intikte of op een knop drukte riep men steevast de methode paint() of repaint() aan. Zouden we in vorige oefening zo gewerkt hebben dan hadden we bij een foutieve invoer gewoon afgedrukt op het canvas foutieve invoer. De werking van de applet lijkt ook correct maar er zit een adder onder het spreekwoordelijke gras. Als men bijvoorbeeld zou het canvas vergroten of verkleinen dan zal Java automatisch een repaint() uitvoeren. Daardoor zal het totaal dat in dit geval ook berekend wordt met repaint() een verschil tonen dat uiteindelijk te danken is aan onze bijkomende repaint() methode die automatisch wordt uitgevoerd. Probeer maar eens u zult merken dat men daardoor eigenaardigheden kan krijgen. De conclusie dat we daaruit kunnen halen is zo geen berekeningen in de methode paint te verzorgen. Voorbeeld: public class metpaint extends Applet { private double in1; private TextField vak; private Button knop; private double totaal; public void init(){ vak = new TextField(10); knop = new Button("knop"); totaal = 0; add(vak); add(knop); public void paint(graphics g){ if(in1 >=1.0 && in1 <=10.0){ totaal +=in1; else{ g.drawstring("geen goede invoer",100,100); g.drawstring("totaal is "+totaal,100,140); public boolean action(event e, Object o){ if(e.target == vak e.target == knop){ String in2 = vak.gettext(); Java 59

60 Double temp = Double.valueOf(in2); in1 = temp.doublevalue(); repaint(); return true; return false; In de verbeterde versie geeft dat dan public class zpaint extends Applet { private double in1; private TextField vak; private Button knop; private double totaal; private boolean geldigeinvoer; public void init(){ vak = new TextField(10); knop = new Button("knop"); totaal = 0; add(vak); add(knop); public void paint(graphics g){ if(!geldigeinvoer){ g.drawstring("ongeldige invoer",100,100); else{ g.drawstring("totaal is "+totaal,100,100); void berekening(){ String in2 = vak.gettext(); Double temp = Double.valueOf(in2); in1 = temp.doublevalue(); if(in1 >=1.0 && in1 <=10.0){ geldigeinvoer = true; totaal += in1; else{ geldigeinvoer = false; public boolean action(event e, Object o){ if(e.target == vak e.target == knop){ berekening(); repaint(); return true; return false; Java 60

61 Er zijn direct een paar, dat er uit springen. Namelijk we werken met een variabele van het type boolean, waarrond gans het programma draait. Deze varabele immers bepaald welke uitvoer we zullen krijgen. Een tweede nieuwigheid is het werken met aparte methoden. Berekening zal in dit geval NIET meet staan in de paint methode maar zal een aparte methode zijn die opgevraagd wordt in actie methode, en dusdanig GEEN effect meer heeft bij het al dan niet gewild herschikken door repaint(). IN het Engels hebben we daar een mooie naam voor. In een programma wordt de berekening veelal het model genoemd. En de paint methode de view. Dus in hoofde van het programmeren zal men steeds, of toch zoveel mogelijk, het model en de view gescheiden houden Exceptions handling In object georiënteerde talen is er een mogelijkheid om bepaalde fouten te laten afhandelen door het programma zelf. Daarvoor zal men, en nu spreek ik over Java, gebruik maken van een fenomeen namelijk EXCEPTION Handeling. We hebben daar vroeger al eens over gepraat, bij het gebruik van de sleep methode, maar gaan daar nu verder op in. De term Exceptions duid dat er in Java iets verkeerd is gegaan. We zouden kunnen stellen iets uitzonderlijk is gebeurt in de verwerking van het programma. Daarmede bedoelen we dat iets uitzonderlijk gebeurt is en niet iets zeer goed. Men wet dat op sommige momenten onvoorspelbare fouten gemaakt worden die, deels afhangen van de programmeur, doch ook kunnen afhangen van de software waarmee men werkt. Er zijn heel veel voorbeelden van deze, een printer zonder papier, een bestand dat niet bestaat, maar ook onverwachte deling door nul enz. De structuur van een Exceptions is heel eenvoudig en in pseudo code als volgt te verwoorden: als(ietsmis) { handel het probleem af anders{ verwerk de normale situatie. Waarmee kan de programmeur nu aangeven, dat er een fout gemaakt wordt of dat er een fout verschijnt. Beginnende programmeurs in Java zullen aannemen dat, en dit volgens andere meer conventionele talen, fouten aangegeven worden door gebruik te maken van booleaanse variabelen. Echter dat is NIET waar in Java. In plaats van variabelen te gebruiken zullen we de aanpak met objecten gebruiken. We zullen, als we een Exceptions willen aangeven, gebruik maken van een instantie van de Exceptions klasse. Java heeft een eigen terminologie voor het gebruik van Exceptions. Het melden van een Exceptions wordt throw genoemd. Het detecteren catch. In Java zullen voor deze acties de woorden: throws, throw, try en catch. Oefeningen zullen verder gebruik wel verduidelijken. import java.awt.*; import java.awt.event.*; import java.applet.*; import java.util.*; public class errorhand1 extends Applet implements ActionListener{ private TextField txtzin, txtresultaat; Java 61

62 private Label lblzin, lblresultaat; public void init(){ txtzin = new TextField(20); txtresultaat = new TextField(20); lblzin = new Label("geef een getal "); lblresultaat = new Label("uitslag"); add(lblzin); add (txtzin); txtzin.addactionlistener(this); add(lblresultaat); add(txtresultaat); public void actionperformed(actionevent event){ if (event.getsource()== txtzin){ try{ int nummer = Integer.parseInt(txtZin.getText()); txtresultaat.settext("het dubbel is"+(2*nummer)); catch(numberformatexception e){ txtresultaat.settext("fout in nummer, voer terug in"); Dit klein voorbeeld laat toe dat u in het eerste veld een letter kunt invoeren en uw programma zal NIET vastlopen. Met andere woorden: we kunnen de fout, welke kan gemaakt worden, opvangen en eventueel verbeteren. U ziet dat dit ons een grote voorsprong geeft in het afwerken van programma s In het helpbestand kunt u een aantal Exceptions vinden waar u gebruik kunt van maken. In verder verloop van de cursus is het heel waarschijnlijk dat we daar verder op zullen terug komen. In uw volgende temaken programma s echter kunt u deze vorm al toepassen om de eventueel gemaakte fouten van de gebruiker te omzeilen. Grammatical: try{ Serie statements; catch(een exception e){ handel deze af; Oefeningen: 1. maak een applet war men een getal invoert gelegen tussen -10 en +10 welke men vermenigvuldigd met een in te geven getal tussen 2 en 5. Vang eventuele gebruikersfouten op. 2. bereken de oppervlakte van een driehoek abc. Met een aparte klasse en methode die de oppervlakte aflevert. De formule is : opp = Math.sqrt(s*(s-a)*(s-b)*(s-c)); waarin s=(a+b+c)/2. probeer terug de eventuele fouten van de gebruiker op te vangen. 3. maak een methode in vorig programma die de schuine zijde berekent van de driehoek (rechthoekige) als de andere zijden gegeven is. Maak met een switch een menu voor dit programma Java 62

63 12.4 While statement, Do statement Zoals we al gezien hebben in andere programmeertalen zal men de FOR structuur steeds gebruiken als men zeker weet hoe groot de herhaling zal zijn. Kent men deze niet dan zal een while statement aangewezen zijn. Vb: public class zolang extends Applet { public void paint (Graphics y){ int getal = 0, som = 0; while(som < ){ getal ++; som +=getal; y.drawstring("de som is "+som,100,100); y.drawstring ("het laatste getal is: "+getal,100,130); Een kleine uitleg. Figuur 37 while som < 1000 getal++ som+=getal druk getal druk som Figuur 38 Het Nassi Sneidermann verklaart de bewerking. We zorgen dat we één integer initialiseren, genaamd getal. Alsook een andere welke de kans geeft om de uiteindelijk bekomen waarde in te bewaren. Java 63

64 Na het while statement, waarin we beslissen dat de loop maximum tot gaat, zullen we in het body beginnen met de teller te verhogen. Een klein verschil met het vorige is dat we hier zelf moeten zorgen voor de verhoging van de teller. In de for structuur deden we dat ook wel, maar daar gebeurde het in de aanroep van de functie. In tegenstelling met hier waar we in het body de teller verhogen. IN het body zullen we ook de berekening uitvoeren. Eens aan de booleaanse waarde gekomen, gaan we uit de lus, en zullen we de uitkomsten afdrukken. De tegenhanger van het while statement is het DO-while statement. In deze gaan we anders te werk: public class totdat extends Applet { private int getal=0, som=0; public void paint(graphics y){ do { getal++; som += getal; while (som < ); y.drawstring(" en de som is: " + som, 100, 100); y.drawstring(" en het laatste getal is" + getal, 100, 130); Figuur 39 U ziet dat de uitslag hetzelfde is, ondanks het verschil in werking. getal++ som += getal zolang (som < ) druk som druk getal Figuur 40 In bovenstaande Nassi Sneiderman zien we terug gemakkelijk de werking van deze lus. Terug gaan we beginnen met een teller te verhogen en nadien deze bij zichzelf op te tellen. Het andere is dat we na dat we dit gedaan hebben controleren als de booleaanse voorwaarde voldaan is. Vorige keer controleerden we vooreerst. Anders is de filosofie volledig gelijk aan het vorige, en kunnen we dit voor het zelfde gebruiken. Het grote gevaar schuilt hem wel hierin dat men we ons gemakkelijk zullen bezondigen aan de zogenaamde endless loop.deze oneindige herhaling zal ons soms kop breken bezorgen. Java 64

65 De enige remedie daarvoor is het programma uitschakelen en hopen dat we niets van onze programmaatje kwijt zijn. Java 65

66 Opgaven: 1. Maak een applet dat concentrische cirkel tekent in het rood. Zorgt ervoor dat men in een tekstvak kunnen ingeven hoeveel cirkels dat men verkiest. 2. Maak een applet waar men in een tekstvak een jaartal ingeeft. De uitvoer moet het zelfde jaartal zijn uitgedrukt in Romeinse cijfers. I =1, V = 5, X = 10, L = 50, C = 100, D = 500 en M = Maak een klasse tijd. Daarin houd men rekening dat deze klasse een tijdingave kan veranderen met als gegeven 60 min in een uur, 60 seconden in een minuut. In een applet zal men door middel van een tekstvak een getal invoeren en als uitkomst de tijd voor wat dit getal staat. 4.Maak een applet die kleiner wordende vierkanten tekent. Het aantal wordt terug ingegeven langs een tekstvak. 5.maak een applet die het mogelijk maakt een aantal cijfers (met max. waarde 10) in te voeren in een tekstvak. Van die cijfers moet de totale som gemaakt worden, het gemiddelde. Men moet ook aanduiden hoeveel cijfers men invoert. Tevens moet men zeggen hoeveel van die cijfers boven 5 liggen en hoeveel onder vijf tevens dient men te zeggen wat het grootste en het laagste cijfer was. Java 66

67 Hoofdstuk 13. Stack Heap Garbadge Collector Vorig jaar en al meermaals in dit jaar hebben we al gesproken over de geheugens toegepast in computers. Evenals het leven van een programma in een computer. Daarin hebben we de noodzaak benadrukt over de werking geheugen van een computer. Niet te verwisselen met het geheugen dat we gebruiken voor het bewaren van een programma. We kunnen dit werkgeheugen onderverdelen in twee delen namelijk de Stack en de Heap Stack Als we een programma schrijven zullen we meestal gebruik maken van variabelen van een bepaald type. Integer (int), String, Double, float, enz. Elk van deze variabelen hebben een bepaalde grote. Deze grote wordt vertaald in het verschil tussen een begin en eindadres in het geheugen. Het deel van het geheugen waar dit in gebeurt, noemt men de stack. Dit is in feite een tabel die waarvan de grote bepaald wordt door de variabele welke men gebruikt. De variabelen welke op de stack staan worden bewaard op die stack zolang ze nodig zijn in het programma gedeelte waar ze worden gebruikt. Moment dat ze niet maar worden gebruikt zal men die plaats op het stack terug vrij geven. Daarin zien we terug hoe men moet voorzichtig zijn met welke soort variabelen men gebruikt. We maken best gebruik van private variabelen. We weten dat deze maar een leeftijd bereiken afhankelijk van de grote van ons programma. Dan kunnen we ook nog gebruik maken van zogenaamde lokale variabelen, deze hebben, zoals we al uit ondervinding weten, maar de leeftijd van een methode waarin ze gebruikt worden. Gebruiken we echter Public variabelen zal deze door gans het programma op het stack bewaard blijven, en deze kunnen ook vanuit andere programma s die op dit moment lopen aangesproken worden. Deze problematiek komen we een beetje verder tegen bij het probleem van incapsulation Dit is in de moderne computers nu niet meer zo een probleem. Immers de geheugens hebben een redelijke grote. Echter geeft dit wel een duiding hoe de persoon zijn programmeertaal beheerst Heap In object georiënteerde taal maken we gebruik van een andere soort geheugen namelijk de Heap. Wat is dit nu. Wel, buiten variabelen werken we in deze taal soorten ook nog met objecten. We hebben al gewerkt met objecten. Bijvoorbeeld, tekstvakjes, knoppen en dergelijke. Steeds zullen we deze objecten aanroepen met het gereserveerde woord new Daarmee zullen we gebruik maken van een constructor. Een constructor zijn we vorige lessen al veel tegen gekomen. Wat doet een constructor?. Een constructor wordt in feite gebruikt om een object te laten construeren. Deze kan echter alles wat een methode kan maar wordt die enkel gebruikt om het ontwerpen van het bepaalde object waarbij we dit aanroepen te verzorgen. Verder in deze cursus zullen we nog dieper ingaan op de constructor. Wat echter nu belangrijk is, is dat steeds als we een Java 67

68 constructor gebruiken, door het gereserveerde woord new, zullen we een kopie van het object op het heap zetten en daarmee verder werken. Deze kopie zal op het heap blijven zolang het programma met dit object zal werken. Stop dit programma met dit object zal het niet direct van het heap verwijderd worden. Op een bepaald ogenblik zal het programma Java een controle uitoefenen naar de nog gebruikte objecten op de heap. Ook zal er nagekeken worden welke van de objecten nog steeds gebruikt worden in het programma. De niet gebruikte objecten zullen op dat moment verwijderd worden. Dit programma onderdeel noemt men de garbadge collector. Hoe weet Java nu welke objecten hij van het heap moet verwijderen? Wel samen met het object wordt er ook plaats gereserveerd voor een teller, de zogenaamde reference count. Steeds als een kopie van het object, of beter het object referentie gebruikt wordt zal de teller verhoogd worden. In het andere geval, steeds als een kopie van de referentie weg valt zal de teller verkleinen. Het moment dat de teller 0 is het object klaar voor geschrapt te worden, en de garbadge collector kan hem weg halen van de heap. Verder in de lessen zullen we dat nog tegen komen en kunnen we de werking ervan bestuderen. Er kan nog veel van deze gezegd worden maar de werking is voor het ogenblik het voornaamste. Hoe deze collector aangesproken wordt hebben we in Java 3 mogelijkheden: - wanneer nodig, als de hoeveelheid overblijvend geheugen op de heap te klein wordt - altijd als de programmator het vraagt - wanneer de collector automatisch de heap controleert. Java 68

69 Hoofdstuk 14. Tabellen (Array s). In iedere programmeertaal, hetzij object georiënteerd of andere is tabellen een belangrijk onderdeel. Denk maar aan het maken van databases. Daarmede gaan we ons nog niet bezig houden en ik denk niet dat dit voor ons is weggelegd. In eerste instantie laat ons even kennis maken met tabellen. We kunnen in deze ofwel waarden van een zelfde primitieve type bewaren, of zelfs objecten. Samen met een array is ook het gebruik van de for lus zeer handig. Immers hierdoor we hebben de mogelijkheid om de elementen (of objecten) één voor één af te lopen. De elementen welke we opbergen in een array noemen we elementen van deze array Het maken van een array in het programma. Eer we een array (tabel) in een programma kunnen gebruiken zijn er een drie tal zaken, dat men voordien dient af te handelen. - In eerste instantie moeten we deze tabel een naam geven. Daardoor zullen we een referentie maken naar het array-object. Herinnert u de naam bij een ander door ons gemaakt object. Zoals steeds is het vrij een naam te kiezen. - Nadat we de naam gekozen hebben, moeten we een nieuw array object aanmaken. Daarvoor gebruiken we het statement new zoals we van eerder gewend waren. Hier echter is het belangrijk de lengte van de array (het aantal elementen) op te geven. - Als laatste dan zullen we de tabel opvullen met waarden. In volgende pagina s zullen we een aantal tabellen maken met objecten en getallen Een tabel met String. In onderdeel 22 hebben we gewag gemaakt van het feit dat een String een object is. En wel zo dat het bestaat uit een rij van karakters. Dit hebben we ook gezien in onze lessen van A & I vorig jaar. Nemen we eens een declaratie van een tabel met 5 onderwerpen. Deze zullen zijn tafel, stoel, zetel, sofa, kast Declaratie String[ ] meubelrij; meubelrij = new String [5]; In de eerste rij staat de naam van de tabel. Dit is de declaratie van de referentie die naar het object verwijst. Een ganse mond vol. In de praktijk wil dat zeggen dat de naam meubelrij een tabel is van elementen. Dat het een tabel is zal men laten zien door de rechte haakjes na type soort welke in de tabel zal opgeslagen worden. Op de volgende lijn gaan we aanduiden dat de tabel bestaat uit een aantal (zie de index) van de bepaalde objecten. Met het gereserveerd woord new zal men de tabel maken en al aanduiden uit hoeveel elementen hij zal bestaan. Natuurlijk spreken we Java 69

70 hier van een tabel met vooraf bepaalde grootte. Natuurlijk zal dat niet steeds het geval zijn, maar later meer daarover Opvullen van de tabel. In de methode init in ons programma kunnen we de tabel al opvullen. We laten dat eens schematisch zien: Index array naam van het element 0 tafel 1 stoel 2 zetel 3 sofa 4 kast We weten dat de tabel uit 5 elementen bestaat. Dus we hebben 5 lege vakjes. Ieder van die vakjes heeft een nummer, namelijk de index. Opgelet deze gaat niet van 1 naar 5 maar wel van 0 naar 4. In Java, C, en meerder andere object georiënteerde talen zal een tabel steeds beginnen met index 0 al eerste element. Het is soms niet logisch en zelfs lastig maar we kunnen daar niets aan veranderen. Als we een tabel declareren moeten we in rekening nemen dat de index steeds begint bij 0. Zoals steeds bij een tabel kan men de inhoud van die tabel toewijzen aan het desbetreffend element. Dit wordt gekenmerkt met de naam van de tabel en zijn index. Hier wordt dat: meubelrij[0], meubelrij[1], meubelrij[2], meubelrij[3], meubelrij[4]. Als we deze dan toewijzen wordt dat: meubelrij[0] = tafel; meubelrij[1] = stoel; meubelrij[2] = zetel; meubelrij[3] = sofa; meubelrij[4] = kast; Index array naam van het element 0 tafel meubelrij[0] 1 stoel meubelrij[1] 2 zetel meubelrij[2] 3 sofa meubelrij[3]; 4 kast meubelrij[4] Bovenstaande is de uiteindelijke opvulling van de tabel. Laten we dat even bekijken in een programma: public class voorbeeld1 extends Applet { private String[] meubelrij; public void init(){ Java 70

71 meubelrij = new String[5]; meubelrij[0] = " tafel"; meubelrij[1] = " stoel"; meubelrij[2] = " zetel"; meubelrij[3] = " sofa"; meubelrij[4] = " kast"; public void paint (Graphics g){ int ypos = 50; for(int a=0; a<5; a++){ g.drawstring(meubelrij[a], 100, ypos); ypos += 30; Figuur 41 U ziet dat door gebruik te maken van de variabele a in de for instructie kunnen we ieder element uit de tabel meubelrij aanspreken, en laten zien op ons scherm. Natuurlijk kunnen we hetzelfde bekomen als we zouden programmeren: g.drawstring( meubelrij[0],100,50); g.drawstring( meubelrij[1],100,80); g.drawstring( meubelrij[2],100,110); g.drawstring( meubelrij[3],100,140); g.drawstring( meubelrij[4],100,170); Maar dit hebben we opgevangen met de variabele a en de verhoging van de variabele ypos. Door gebruik van de for instructie kan men grotere tabellen aanspreken. Deze for instructie kan gebruikt worden, en dat is in alle programmeertalen, als de grote van de tabel gekend is. De bovengrens van een tabel is de grootste waarde die een index kan aannemen Deze is in de Java taal beschermd, in tegenstelling in andere talen. Darmede wordt bedoeld dat u niet moet proberen om een tabelcel bij te creëren buiten de bovengrens van de tabel. Dan zal men direct een fatale error krijgen. Namelijk de IndexOutofBound Exceptions. Deze kan terug opgevangen worden. Java 71

72 Let wel op dit feit. Kan grote problemen veroorzaken bij het programmeren. Om dit te voorkomen kan je best het aantal elementen van een tabel als constante programmeren. Dit gebeurt met een gereserveerd woord final. De naam die na dit woord komt zal men steeds met hoofdletters schrijven, zie voorbeeld public class voorbeeld1 extends Applet { private String[] meubelrij; final int AANTALMEUBELEN = 5; public void init(){ meubelrij = new String[AANTALMEUBELEN]; meubelrij[0] = " tafel"; meubelrij[1] = " stoel"; meubelrij[2] = " zetel"; meubelrij[3] = " sofa"; meubelrij[4] = " kast"; public void paint (Graphics g){ int ypos = 50; for(int a=0; a<aantalmeubelen; a++){ g.drawstring(meubelrij[a], 100, ypos); ypos += 30; Zoals u ziet hebben we hierdoor steeds de zelfde waarde Namen van tabellen. In de programma s zullen we een naamgeving toepassen die aanduidt wat soort variabele we gebruiken. Dit gebeurt door voor een tabel aan te duiden dat het om een rij gaat. Voorbeeld: meubelrij, getallenrij enz. Daardoor herkennen we het object tabel (array) die we in ons programma kunnen ontwikkelen Tabel van getallen tabel met gehele getallen. Om deze op te maken gebruiken we in principe hetzelfde systeem als met de String. Bekijk even het voorbeeld. public class voorbeeld2 extends Applet { private final int AANTAL = 5; Java 72

73 private int [] getalrij; public void init(){ getalrij = new int[aantal]; for (int a = 0; a < AANTAL; a++) { getalrij[a] = a + 3; public void paint(graphics g){ int ypos = 50; for(int a=0; a< AANTAL;a++){ g.drawstring(string.valueof(a+1)+". "+getalrij[a],100,ypos); ypos +=30; Figuur 42 Dit is een voorbeeld van een gewone tabel met getallen Tabel met komma getallen. Het gebruik van double als primitief type is natuurlijk ook mogelijk. Hierbij moeten we dan de declaratie aanpassen zoals in het voorbeeld: public class voorbeeld2 extends Applet { private final int AANTAL = 5; private double [] getalrij; public void init(){ getalrij = new double[aantal]; for (int a = 0; a < AANTAL; a++) { getalrij[a] = a * 0.3; public void paint(graphics g){ int ypos = 50; for(int a=0; a< AANTAL;a++){ g.drawstring(string.valueof(a+1)+". "+getalrij[a],100,ypos); ypos +=30; Java 73

74 Figuur 43. In dit geval hebben we mogelijkheid tot gebruik van een speciale manier om de tabel te vullen namelijk met random getallen. We weten van vorige programmeertalen dat random getallen, getallen zijn die gemaakt worden door de computer en die, door gebruik te maken van de systeemdatum en tijd, gegenereerd worden. Dat is niet verschillend bij Java. Echter moeten we wel nota nemen van het feit dat random getallen bij Java gelegen zijn tussen o en 1, en dus steeds van het type Double of komma getallen zijn. Bekijk even volgend voorbeeld public class voorbeeld3 extends Applet { private final int AANTAL = 6; private double[] randomrij; public void init(){ randomrij = new double[aantal]; for(int a=0; a<aantal;a++){ randomrij[a]= Math.random(); public void paint(graphics g){ int ypos = 50; for(int a=0; a<aantal;a++){ g.drawstring(string.valueof(a+1)+". "+ randomrij[a],50,ypos); ypos +=30; Figuur 44 Merk op dat random een methode is uit de klasse Math. In deze klasse zitten de meeste methoden die iets te maken hebben met wiskunde. We hebben al een oefening Java 74

75 gemaakt waar we de constante Pi nodig hadden. Denk maar aan de oppervlakte van een cirkel. We kunnen deze ook met meer precisie laten bereken met de methode Math.PI. Deze geeft als uitkomst:3, In onze programma s zullen we dat niet bemerken maar de berekeningen zullen accurate zijn. Oefeningen. 1. Construeer, in analogie met een van de vorige oefeningen, twee tabellen die in de eerste tabel de bewerking voorstelt en in de tweede tabel de uitkomst van de tafel van Maak een tabel met 10 bij toeval gegenereerde getallen. Door de druk op een knop moet men de som van die getallen afdrukken in een tekstveld. 3. Maak een tabel van de bestaande klassen in de school. Voer deze in een tekstveld. Als deze ingevuld zijn druk ze af op het canvas Zoeken in een tabel. Een van de functies die men op een tabel uitoefent is het zoeken in deze tabel. De elementen welke men zoekt moeten aan een bepaald criterium, nl. de zoek String, voldoen. Nemen we als voorbeeld de tabel van vorig voorbeeld. Daarin moeten we als zoek String het grootste element zoeken. Normaal zegt men we gaan deze tabel eerst sorteren en daardoor de grootste vinden. Hier kunnen we dat ook anders oplossen. public class voorbeeld4 extends Applet { private final int AANTAL = 6; public double[] randomrij; public double maximum ; public void init(){ randomrij = new double[aantal]; for(int a=0; a<aantal;a++){ randomrij[a]= Math.random()*10; for (int b=0; b< AANTAL;b++){ if(maximum < randomrij[b]) maximum = randomrij[b]; public void paint(graphics g){ int ypos = 50; for(int a=0; a<aantal;a++){ g.drawstring(string.valueof(a+1)+". "+ randomrij[a],50,ypos); ypos +=30; g.drawstring("het grootste getal is "+maximum, 50,yPos); Java 75

76 Figuur Een tabel als argument in een methode. In een programma met tabellen zal het regelmatig voorkomen dat de bewerkingen op een tabel zal laten geschieden in een tabel door middel van een methode. Bekijken we eens volgend voorbeeld: import java.awt.*; import java.awt.event.*; import java.applet.*; /** * <p>title: </p> * <p>description: </p> * <p>copyright: Copyright (c) 2004</p> * <p>company: </p> not attributable 1.0 */ public class methode extends Applet { private int[] lengterij = {146,95,120,150,210; private int[] breedterij= {50,30,14; private int grootel, grooteb; public void init(){ grootel = max(lengterij); grooteb = max(breedterij); public void paint (Graphics g){ g.setfont(new Font("Arial",Font.BOLD,16)); g.drawstring("de grootste Lengte is: "+grootel,50,50); g.drawstring("de grootste breedte is:" +grooteb,50,70); int max(int[] rij){ int maximum= rij[0]; for(int i = 0;maximum<rij.length ;i++){ if(maximum < rij[i]){ maximum = rij[i]; Java 76

77 return maximum; Figuur 46 Hier zien we dat we gemakkelijk een methode kunnen schrijven die we gebruiken in een programma met tabellen zoeken in een tabel Zoals in vorig geziene talen zoals Pascal is het ook hier volstrekt mogelijk een zoek functie los te laten op een tabel. Hierin kunnen we bijvoorbeeld bepalen als het gevraagde voorkomt in de tabel en de index van die waarde. Een voorbeeld zal duidelijkheid scheppen. import java.awt.*; import java.awt.event.*; import java.applet.*; /** * <p>title: </p> * <p>description: </p> * <p>copyright: Copyright (c) 2004</p> * <p>company: </p> not attributable 1.0 */ public class zoeken extends Applet { private int ZoekGetal, index; private int[] getalrij ={10,12,15,18,30,44,56,88,62,30; public void init(){ ZoekGetal = 56; index = zoek(getalrij,zoekgetal); public void paint(graphics g){ int posx = 20; for(int i = 0; i<getalrij.length ;i++){ g.drawstring(""+getalrij[i],posx,50); posx+= 30; g.drawstring("het getal "+ZoekGetal,50,80); if (index >=0){ g.drawstring("heeft als index "+index+" dit is het "+ " getal "+(index+1)+" in de tabel",50,100); else{ Java 77

78 g.drawstring("komt niet voor in de lijst",50,100); public int zoek(int[] rij, int getal){ for (int i = 0; i < rij.length; i++) { if (rij[i] == getal) return i; return -1; Figuur 47 Door de methode zoek zal men de bepaalde waarde opzoeken in een tabel. Let wel de index is altijd de plaats -1 van het getal. Immers we weten dat een tabel in Java steeds met getal 0 begint. Oefeningen 1. ontwerp een programma waar een getal moet zoeken in een rij. Dit getal wordt ingegeven in een tekstvak. In eerste instantie geeft men aan als het getal n die rij zou kunnen te vinden zijn. Als het gevonden is geeft men tevens de index en de plaats aan in die rij. Die rij is: getalrij = {10,52,36,74,11,1,25,42,63,8. 2. In vorige oefening hebben we eens een staafdiagram ontwikkeld. Nu, met behulp van de tabellen structuur kan men dit ook. Als oefening druk een staaf diagram af voor de getalrij = {10,24,36,44, Polygonen Een polygoon of veelhoek hebben we in het begin van de cursus over gelaten. We wisten dan nog niet hoe werken met een tabel. Nu kunnen we er even verder op ingaan. Bekijk even volgend voorbeeld: import java.awt.*; import java.awt.event.*; import java.applet.*; public class polygoon extends Applet { private Polygon pijl; private int[] xrij = {50,100,100,150,100,100,50; private int[] yrij = {100,100,60,125,190,150,150; private final int AANTALPUNT = xrij.length; public void init(){ pijl = new Polygon(xRij,yRij,AANTALPUNT); Java 78

79 public void paint(graphics g){ g.drawpolygon(pijl); pijl.translate(150,0); g.setcolor(color.blue); g.fillpolygon(pijl); Figuur Invoeren via een tekstvak De gegevens in een tabel kunnen ook ingevoerd worden met het gebruik van een tekstvak. In eerste instantie denken we aan het gebruik van zoveel tekstvakken als er plaats is in de tabel. Bekijk eens volgend voorbeeld: public class tekstvak extends Applet { private final int AANTAL = 3; private String[] voornaamrij; private TextField[] tekstvakrij; public void init(){ voornaamrij = new String[AANTAL]; tekstvakrij = new TextField[AANTAL]; for(int nr=0;nr < AANTAL;nr++){ tekstvakrij[nr] = new TextField(12); voornaamrij[nr] = String.valueOf(nr + "."); add(tekstvakrij[nr]); public void paint(graphics v){ int ypos = 150; for(int nr = 0; nr < AANTAL; nr++){ v.drawstring(voornaamrij[nr],50,ypos); ypos +=20; public boolean action(event e, Object o){ for (int i=0; i< AANTAL; i++){ if(e.target == tekstvakrij[i]){ voornaamrij[i] = String.valueOf(i) +"."+tekstvakrij[i].gettext(); repaint(); return true; Java 79

80 return false; Figuur 49 In dit geval zullen we steeds als we een naam inbrengen moeten drukken op enter opdat die naam verschijnt. De invoer via een enkel tekstvak is natuurlijk beter in zo een geval. We bekijken eens volgend voorbeeld: public class tekstvak1 extends Applet { private int nr; private TextField tekstvak; private Label[] labelrij; private Button resetknop; private final int AANTAL= 4; private String[] naamrij; public void init(){ nr = 0; tekstvak = new TextField(12); labelrij = new Label[2]; labelrij[0] = new Label("voer "+AANTAL+" namen in"); labelrij[1] = new Label("Druk na elke naam op enter"); resetknop = new Button("reset"); naamrij = new String[AANTAL]; for(int i = 0; i < AANTAL; i++){ naamrij[i] = String.valueOf(i)+"."; add(labelrij[0]);add(labelrij[1]); add(tekstvak);add(resetknop); public void paint (Graphics g){ int ypos = 100; for(int i=0; i<aantal;i++){ g.drawstring(naamrij[i],50,ypos); ypos +=20; Java 80

81 public boolean action(event e, Object o){ if (e.target == tekstvak){ if(nr < AANTAL){ naamrij[nr] = String.valueOf(nr+". "+tekstvak.gettext()); nr++; tekstvak.settext(""); repaint(); return true; if(e.target == resetknop){ tekstvak.settext(""); nr = 0; for(int i = 0; i<aantal; i++){ naamrij[i] = String.valueOf(i)+"."; repaint(); return true; return false; Figuur meer dimensionale tabellen. Zoals in alle andere programmeer omgevingen is het ook mogelijk in Java te werken met meer dimensionale tabellen. Vb. testmatrix Tweede Index Eerste Index Java 81

82 Omdat in Java de index steeds met 0 begint kunnen we het eerste element( linksboven) aanduiden als het element testmatrix[0][0]; en rechtsonder of het laatste element testmatrix[2,3]. Eigenaardig zult u zeggen maar vergeet niet dat de indexen in Java met 0 beginnen. Dus daar kunnen we van afleiden dat volgende stelling waar is: NaamTabel[rij][kolom]. In bovenstaand geval kunnen we ook zien dat de lengte van een rij gelijk is aan NaamTabel][0].length of de lengte van de 0 de rij. In dit geval ziet u dat de lengte van iedere rij niet moet gelijk zijn. Bekijken we eens volgend voorbeeld. Daarin kunnen we zien hoe men een matrix kan benaderen. public class tweedimensie1 extends Applet { private int testmatrix[][] = { {10,23,11,4, {4,5,6,9, {123,158,132,444 ; public void paint(graphics g){ for(int rij = 0;rij < testmatrix.length;rij++){ for(int kol=0;kol<testmatrix[rij].length;kol++){ g.drawstring(""+testmatrix[rij][kol],50+kol*40,100+rij*30); Figuur 51 Deze matrix kan ook gebruikt worden als een argument van een methode. Laat ons eens volgend voorbeeld bekijken: public class tweedimensie1 extends Applet { private int testmatrix[][] = { {10,23,11,4, {4,5,6,9, {123,158,132,444 ; public void paint(graphics g){ int resultaat = matrix.totaalrij(testmatrix,0); g.drawstring("totaal voor de 1ste rij is: "+resultaat,50,100); Java 82

83 class matrix{ static int totaalrij(int matrix[][], int rij){ int totaal = 0; for(int kol = 0; kol < matrix[rij].length;kol++) totaal +=matrix[rij][kol]; return totaal; Figuur 52 Oefening: In bovenstaand voorbeeld maakt dat de rij welke men wil bevragen toegankelijk is voor de gebruiker. Java 83

84 Hoofdstuk 15 Overerving In deel 23 hebben we gesproken over klassen. Met deze hebben we leren werken en hun voordelen leren appreciëren. Nu bezit Java ook een krachtig wapen namelijk de overerving. Dit bestaat hierin dat een nieuwe klasse kan gevormd worden met de eigenschappen van een vorig gemaakte klasse, en eventueel nog een paar eigenschappen van zich zelf erbij. De superklasse of de klasse waaruit we eigenschappen erven (attributen en methodes) blijven echter nog steeds in die superklasse. Het is een redelijk moeilijke materie maar je maakt er al gebruik van Een superklasse. Bekijken we eens volgend voorbeeld: import java.awt.*; import java.awt.event.*; import java.applet.*; class Rechthoek{ private int b = 250, h = 70; void toon(graphics g){ g.drawrect(100,50,b,h); public class rechthoek1 extends Applet { private Rechthoek r; public void init(){ r = new Rechthoek(); public void paint (Graphics g){ r.toon(g); In deze oefening kunt u zien dat het een normaal programma is welke we in het deel 23 geconstrueerd hebben. We gaan nu deze klasse rechthoek een beetje uitbreidden en dit door ofwel meer methoden in de subklasse toe te voegen ofwel een nieuwe subklasse toe te voegen Subclasse Bestudeer even volgende code: class Rechthoek{ protected int b = 250, h = 70; Java 84

85 void toon(graphics g){ g.drawrect(100,50,b,h); class groeien extends Rechthoek{ void breder() { b++; void hoger() { h++; public class rechthoek1 extends Applet { private groeien r; public void init(){ r = new groeien(); public void paint (Graphics g){ for(int x=0; x<10;x++){ r.toon(g); r.breder(); r.hoger(); Zoals je bemerkt heeft de tweede tekening een drie dimensioneel effect. Dit wordt veroorzaakt door die tweede klasse die toegevoegd werd. Door de breedte en de hoogte te vergroten volgens een constante factor krijgen we dit effect. In de code bemerken we dat in de tweede klasse geschreven wordt dat die afhankelijk is van de eerste klasse door de bijvoeging extends. Daardoor erft de tweede klasse de eigenschappen van de eerste klasse en voegt er zijn eigenschappen toe. Let wel we zien nu een andere benoeming namelijk protected. De leden die protected zijn, zijn toegankelijk vanuit de subklassen. Zij zijn ook toegankelijk van alle klassen in het zelfde package maar NIET van daarbuiten Toegangsregels van klasse leden. Private, protected en public zijn access-modifiers (toegang mogelijkheden) van de klasse. Zij geven aan hoe de toegang tot een bepaald lid van de klasse geregeld is. Laat ze ons eens stuk voor stuk bekijken: private deze zijn enkel toegankelijk vanuit de eigen klasse. Zij zijn niet toegankelijk van buiten uit de klasse ook NIET van subklasse. Java 85

86 public deze zijn toegankelijk van overal. Dus van sub klassen, vanuit de klasse of zelfs van buiten de klasse. Als deze woorden ontbreken dan heeft desbetreffende klasse lid een package toegang. Een package of project heeft volgende kenmerken: - de klassen van een package horen bij elkaar - de klassen staan in dezelfde folder(subdirectory) - de naam van de subdirectory is de naam van het package (project) protected deze zijn toegankelijk vanuit alle klassen binnen het package. Tevens van alle subklasse ook al zitten deze niet in het zelfde package. Vanuit de andere klassen zijn de protected leden niet toegankelijk Toegang in één package Binnen een package geld namelijk: Public toegang = protected toegang = package toegang. In feite zijn er in een package maar twee soorten toegang namelijk private en niet private. Of te wel toegang binnen in een package en toegang van buiten af. Als Java programmeur is het belangrijk te denken hoe men de klassen zullen gebruiken. Het is best mogelijk dat men uw klassen zullen gebruikt worden door meerdere personen en programma s. Dus het is wel nodig dat men denkt over het gebruik van de soorten toegang als men een klasse schrijft. 31. Subklasse van een subklasse Men kan meerder subklassen is een programma plaatsen import java.awt.*; import java.awt.event.*; import java.applet.*; public class subklasse3 extends Applet { public void paint(graphics g){ new Vierkant (100).teken(g); class Veelhoek{ private int aantalh; public Veelhoek(int aantalh){ this.aantalh = aantalh; Java 86

87 class Vierhoek extends Veelhoek{ public Vierhoek(){ super(4); class Rechthoek extends Vierhoek{ private int breedte, hoogte; public Rechthoek(int breedte, int hoogte){ this.breedte = breedte; this.hoogte = hoogte; public void teken(graphics g){ g.drawrect(10,10,breedte, hoogte); public void setbreedte(int breedte){ this.breedte = breedte; public void sethoogte(int hoogte){ this.hoogte = hoogte; public int getbreedte(){ return breedte; public int gethoogte(){ return hoogte; class Vierkant extends Rechthoek{ public Vierkant(int zijde){ super(zijde, zijde); public void sethoogte(int hoogte){ super.sethoogte(hoogte); super.setbreedte(hoogte); public void setbreedte(int breedte){ super.setbreedte(breedte); super.setbreedte(breedte); public int getzijde(){ return gethoogte(); Natuurlijk is dat een grote programmering vergeleken met wat men krijgt. Maar laat me het programma eens uitleggen: We maken een vierkant door de constructor Vierkant(100) aan te roepen met het geven van de grootte van de zijde. Java 87

88 Het moment dat we deze aanroepen roepen we in feite de klasse Rechthoek aan immers door constructor van vierkant aan te roepen we in feite super(zijde, zijde) aan. Daar Rechthoek de superklasse is roepen we in feite Rechthoek(zijde, zijde) aan. We zien dat in de constructor Rechthoek niet het eerste statement een aanroep van super() is. Dus zal de compiler 'de default' constructor van vierhoek aanroepen. Als de super klasse een constructor heeft kan je de overgeërfde attributen door de constructor van de superklasse laten initialiseren door middel van het woord super. De constructor van vierhoek bestaat maar uit 1 statement: super(4); Die wordt gelezen als Veelhoek(4); Daardoor krijgt het attribuut aantal hoeken de waarde 4. Door het statement this.breedte = breedte en this.hoogte = hoogte met als waarde 100 voor beiden krijgt de constructor Rechthoek zijn waarden. Daardoor is de constructor van Vierkant ook in orde. Natuurlijk is dit een beetje teveel van het goede maar dat duid hoe een Java programma in elkaar zit. In deze taal zal men voortdurend werken met overerving en overriding. Overriding is andere waarde geven aan een bepaalde methode. Door dit statement gaat u de bestaande warden van een methode een andere waarde geven als men deze methode aanroept final Voordien hebben we al de modifier kort besproken. Zoals u weet wordt dit gebruikt om een constante aan te duiden. Een subklasse kan in feite alles overerven uit de superklasse maar niet de constructoren en finalizer. Een finalizer is in feite het omgekeerde van een constructor. Door het woordje final voor een methode te plaatsen maak je een finalizer en maak je het onmogelijk van overriding te gebruiken. Methoden die static of private gedeclareerd zijn kan je overriden, dus daar staat ook final bij. Oefeningen: Maak een Applet met klasse Rechthoek met private attributen. Zorg dat de klasse een constructor heeft die de rechthoek kan tekenen. Gebruik een subklasse om er een titelbalk in te tekenen (in deze titelbalk plaatsen we Titel ). Maak een klasse cirkel met als attributen straal, de coördinaten van het middelpunt. Maak een methode teken() waar mede men de cirkel tekent. maak een subklasse cilinder van een klasse die een cirkel maakt. Cirkel is de grondplaat van de cilinder. Java 88

89 Hoofdstuk 16. Gebruikers Interface Gebruikers interface heeft verschillende ingrediënten. De tekstvakken, knoppen, labels, schuifbalken zijn maar enkele daarvan. Gebruikers interface, ook gekend als GUI, Graphical User Interface, is een wijze tot benadering van een programma. U begrijpt wel dat de aantrekkelijkheid van een programma deels afhangt van de GUI. De meeste programma s bieden een user interface welke toelaat gemakkelijk zo iets te ontwerpen. Dit is ook het geval met JBuilder. In een later stadia kunnen we deze nog eens bestuderen. Gelukkig bied Java zelf ook een manier om eenvoudige en mooi ogende gebruiker interfaces te maken. Dit met behulp van zogenaamde containers. Een container is een object waar je een of meer componenten kunt in stoppen. Knoppen, labels en tekstvakken zijn enkele voorbeelden van objecten. Een Applet welke je schrijft is in feite een deel van een container, of beter een Applet is een subclasse van de classe container. Met behulp van de methode add() voeg je een component toe aan de container. Ieder van deze componenten hebben hun eigen methodes paint(), die automatisch wordt aangesproken op het moment dat die component op het scherm moet komen. De lay-out manager van de container geeft de precieze plaats op het scherm Standaard lay-outmanager In vorige oefeningen heb je al meermaals gebruik gemaakt van de standaard lay-out manager. Immers altijd dat je een object op het scherm brengt heb je de standaard lay-out manager gebruikt. Bekijk onderstaand voorbeeld: import java.awt.*; import java.awt.event.*; import java.applet.*; public class standaard extends Applet { private TextField txt1, txt2, txt3; public void init(){ txt1=new TextField("jan",50); txt2=new TextField("piet",50); txt3 = new TextField("karel",50); add(txt1);add(txt2);add(txt3); Figuur 53 Dit is een voorbeeld van de standaard lay-out manager welke in Java ingebed zit. Zoals u op de oefening ziet hebt u deze al regelmatig gebruikt De Border lay-out Java 89

90 Een gans andere lay-out zult u verkrijgen als u gebruik maakt van de borderlay-out. Deze layout verdeelt het gebied waar hij met werkt in een aantal gebieden. Deze worden aangeduid als North, West, Centrum, East, en South. Bekijken we eens het voorbeeld: import java.awt.*; import java.awt.event.*; import java.applet.*; public class borderlayout extends Applet { private TextField txt1,txt2,txt3,txt4,txt5; public void init(){ setlayout(new BorderLayout()); txt1 = new TextField("Jan (Noord)"); txt2 = new TextField("Piet (zuid)"); txt3 = new TextField("Karel (centrum)"); txt4 = new TextField("Jors (west)"); txt5 = new TextField("Marie(oost)"); add("north",txt1); add("south",txt2); add("center",txt3); Figuur 54 Door deze lay-out zijn de tekstvakken zo uitgetrokken dat je moeilijk nog van tekstvakken kunt spreken. Wel is duidelijk herkenbaar is de plaats van de vakken. Zoals je ziet is dit verdeeld in 5 aparte vakken. Hoewel deze lay-out manager niet geschikt is voor tekstvakken kan hij uitstekend dienst doen als basislay-out voor een Applet. Als je eens en standaard lay-out van een Windows applicatie bekijkt zie merkelijke gelijkenissen met deze lay-out. Immers je hebt bovenaan een menubalk (noord), onderaan waar mededelingen worden gedaan (zuid) een schuifbalk aan de linker zijde (west) en de rechterzijde(oost). Het centrum blijft dan nog over waar je tekst of tekeningen kunt in plaatsen Tussen ruimte De border lay-out is een object met de nodige constructor. Niet allen een default constructor (zie boven) maar echter ook een mogelijkheid met de volgende argumenten. Public BorderLayout(int hgap, int vgap); Als we in vorige oefening new BorderLayout een verander in new BorderLayout(40,10) komen we het volgende uit: Figuur 55 Java 90

91 16.3 Borderlay-out met minder componenten Het is niet altijd nodig dat we 5 componenten een border lay-out zetten. Het leuke van die layout is dat we ook minder componenten in de container kunnen plaatsen. Volgend voorbeeld geeft u de mogelijkheid tot gebruik van maar 2 componenten import java.awt.*; import java.awt.event.*; import java.applet.*; public class borderlayout2 extends Applet { private Button knop1,knop2; public void init(){ setlayout(new BorderLayout()); knop1 = new Button("centrum"); knop2 = new Button("zuid"); add("center",knop1); add("south",knop2); Figuur 56 Een Applet met enkel een knop lijkt nogal zinloos. We hebben nog andere componenten die we kunnen gebruiken: - Button knop - Canvas om op te tekenen doek - ChckBox selectievak - Choise list die bvb tevoorschijn komt als je er op klikt - Label plaats voor tekst die de gebruiker niet kan wijzigen - List zichtbare lijst waar men onderwerpen kan uit kiezen Java 91

92 - Panel subcontainer. Dit is een bijkomende container waar je componenten kunt in plaatsen - TextComponet tekst vak of een tekst area waar men tekst kan inbrengen - Scrollbar schuifbalk. In verdere delen zullen we de andere nog niet bekende objecten bespreken Een goede lay-out Zoals we al meerdermaal benadrukt hebben is een goede lay-out essentieel voor een programma en zijn gebruiker. Alles moet zo duidelijk zijn dat hij of zij met 1 blik weet wat er gedaan moet worden. Object component Button CheckBox container list textcomponent canvas choise label scrollbar textbox textarea Window Panel Frame Applet Figuur 57 Uit bovenstaande overervingboom kunnen we zien dat een Applet in feite een subklasse is van een panel die op zijn beurt een subklasse is van een container. Of een Applet is een indirecte subklasse van een container. Java 92

93 Text area panel Figuur 58 Twee van die componenten zijn bij voorbeeld Textarea en Panel. Zoals je ziet op figuur 58 Gebruiken we een border lay-out om de vorm te geven. Dan zetten we bijvoorbeeld in het gedeelte centrum de textarea, en in het gedeelte south het panel. Omdat panel op zijn eigen ook een container is kan men daar ook componenten in plaatsen. Bijvoorbeeld een drietal knoppen. Voor het panel gebruiken we de standaard lay-out. Bestudeer volgend voorbeeld: import java.awt.*; import java.awt.event.*; import java.applet.*; public class Voorbeeld extends Applet { private TextArea tekstgedeelte;// om tekst in te plaatsen private Panel knoppengedeelte;// commando gedeelte private Button k1,k2,k3; public void init(){ setlayout(new BorderLayout()); tekstgedeelte = new TextArea(); add("center",tekstgedeelte); knoppengedeelte = new Panel(); add("south",knoppengedeelte); k1=new Button("1"); knoppengedeelte.add(k1); k2=new Button("2");knoppenGedeelte.add(k2); k3=new Button("3");knoppenGedeelte.add(k3); De uitvoer van dit programma is te zien in figuur 59. Merk op dat ondanks de code voor deze Applet betrekkelijk eenvoudig is de uitvoering redelijk complex is. Java 93

94 Figuur 59 Textarea, een component die we toegevoegd hebben heeft is op zijn eigen een klasse. Deze klasse heeft 5 constructoren. TextArea(String text, int rows, int cols, int scrollbars) TextArea() geeft enkel een leeg tekst gebied, String tekst maakt een tekstgebied waar men tekst kan in plaatsen. TextArea(String tekst) maakt een tekst gebied met de tekst er in geplaatst. int rows, int cols maakt een leeg tekstgebied met het aantal rijen en kolommen zoals bepaald. TextArea(String tekst, int rows, int cols) maakt en tekstgebied met de opgegeven tekst en aantal rijen en kolommen. Het argument int scrollbars geeft de scrollbars aan op het einde van het tekst gebied. Daar hebben we verschillende mogelijkheden: TextArea.SCROLLBARS_BOTH beide, dat is ook de default uitvoering TextArea.SCROLLBARS-HORIZONTAL-ONLY enkel de horizontale TextArea.SCROLLBARS-NONE geen scrollbar TextArea.SCROLLBARS-VERTICAL-ONLY enkel de verticale Andere soorten lay-out Buiten de voordien geziene lay-outs bezit Java nog de mogelijkheid om 3 andere lay-out vormen te gebruiken Gridlay-out Deze verdeeld de componenten in een container in een tabelvorm over de ruimte die de container heeft. Het aantal rijen en kolomen wordt bij het aanroepen van de constructor mee gegeven. De klasse Gridlayout heeft twee verschillende contructoren - public GridLayou(int rows, int cols); - public GridLayout(int rows, int cols, int hgap, int vgap); probeer eens volgend voorbeeld: public class grid extends Applet { Canvas canvas; Panel paneel; public void init(){ Java 94

95 //met border lay-out setlayout(new BorderLayout()); // maak een oppervlakte in de applet met canvas canvas = new Canvas(); canvas.setbackground(color.cyan); // plaats dit canvas in het midden add("center",canvas); // maak een paneel met gele achtergrond paneel = new Panel(); paneel.setbackground(color.yellow); // Gerote letters voor de componenten in het paneel paneel.setfont(new Font("Arial",Font.BOLD,16)); // geef een Gridlayout aan het paneel paneel.setlayout(new GridLayout(2,3)); //maak de componenten voor het paneel Button knop,knop2; Label label, label2; TextField tekstvak, tekstvak2; knop = new Button("knop1"); knop2 = new Button("knop2"); label = new Label("label1"); label2 = new Label("label2"); tekstvak = new TextField("tekstvak1"); tekstvak2 = new TextField("tekstvak2"); // voeg de componenten toe aan het paneel paneel.add(knop); paneel.add(label);paneel.add(tekstvak); paneel.add(knop2); paneel.add(label2);paneel.add(tekstvak2); // voeg het paneel onderaan de applet add("south",paneel); Java 95

96 In deze code komen we nog en paar nieuwe commando s tegen. Het eerste is het opzetten van het canvas. Het canvas is het vlak dat tevoorschijn komt en waarin we de gegevens laten verschijnen. Altijd hebben we de default kleur van het canvas genomen. Nu kunnen we dit ook veranderen. Let wel het canvas is een constructor dus moet gemaakt worden met new. We kunnen nu gebruik maken van de bij het object horende methoden. De meest voorkomende echter is setbackground() met een kleur. Het zelfde kunnen we nu met de achtergrond van het paneel welke we op geel vast zetten. Nadien beginnen we de componenten van het paneel te maken en te plaatsen. Wat nu echter opvalt, is dat de teksten van de label links tegen de knopen geplakt zijn. Dit kunnen we echter veranderen door bij het aanmaken van het object Label er een plaats voor de tekst aan toe te voegen. Deze gebeurt als: Label = new Label( label1,label.center); Let wel op dat men hoofdletters gebruikt voor de plaats aanduiding. men kan ook de Font veranderen van de tekst door met setfont te werken. Vroeger gebruikten we dit veelal in samenwerking met de methode Graphic g waar we schreven g.setfont(new Font( Helvetica,Font.BOLD,16); Cardlay-out Een andere mogelijkheid is dan nog de CardLayout. Met deze kunt u de componenten rangschikken als was het een stapel kaarten. De Cardlayout wordt weinig gebruikt. Voorbeeld public class cardlayout extends Applet { Panel linkerpaneel, rechterpaneel; CardLayout cardlayout; Button eersteknop, laatsteknop, vorigeknop, volgendeknop, tweeknop, drieknop; public void init(){ //kiezen voor een gridlayout met 1 rij en twee kolommen setlayout(new GridLayout (1,2)); //maak een paneel rechts voor de stapel kaarten rechterpaneel = new Panel(); // geef referentie naar een object van CardLayout- nodig voor de methode action() cardlayout = new CardLayout(); // geef het rechterpaneel de card lay-out rechterpaneel.setlayout(cardlayout); //maak eerste kaart met canvas Canvas kaart1 = new Canvas(); kaart1.setbackground(color.yellow); Java 96

97 // maak en tweede kaart Panel kaart2 = new Panel(); kaart2.setfont(new Font("Helvetica",Font.BOLD,16)); kaart2.add(new Button("knop1")); kaart2.add(new Button ("knop2")); // maak een derde kaart Panel kaart3 = new Panel(); kaart3.setlayout(new GridLayout(2,1)); kaart3.setfont(new Font("Times Roman", Font.ITALIC, 30)); kaart3.add(new TextField("tekstvak1")); kaart3.add(new TextField("tekstvakd2")); // maak een vierde kaart Label kaart4 = new Label("dit is de laatste kaart"); kaart4.setfont(new Font("Helvetica",Font.BOLD, 16)); // toevoegen van de kaarten in het rechter paneel rechterpaneel.add("kaart 1",kaart1); rechterpaneel.add("kaart 2",kaart2); rechterpaneel.add("kaart 3",kaart3); rechterpaneel.add("kaart 4",kaart4); // maak in het linkse paneel 6 knoppen in 2 rijen 3 kolommen linkerpaneel = new Panel(); linkerpaneel.setlayout(new GridLayout(3,2)); linkerpaneel.setfont(new Font("Helvetica",Font.BOLD,16)); // maak 4 knoppen voor dit paneel eersteknop = new Button("eerste kaart");laatsteknop = new Button("laatste kaart"); vorigeknop = new Button("vorige");volgendeKnop = new Button("volgende"); tweeknop = new Button("kaart 2");drieKnop = new Button("kaart 3"); linkerpaneel.add(eersteknop);linkerpaneel.add(laatsteknop); linkerpaneel.add(vorigeknop);linkerpaneel.add(volgendeknop); linkerpaneel.add(tweeknop);linkerpaneel.add(drieknop); // voeg beide panelen toe aan het applet add(linkerpaneel); add(rechterpaneel); public boolean action(event e, Object o){ if (e.target == eersteknop){ cardlayout.first(rechterpaneel); return true; if (e.target == laatsteknop){ cardlayout.last(rechterpaneel); return true; if (e.target == volgendeknop){ cardlayout.next(rechterpaneel); return true; if (e.target == vorigeknop){ cardlayout.previous(rechterpaneel); return true; Java 97

98 if (e.target == tweeknop){ cardlayout.show(rechterpaneel,"kaart 2"); return true; if (e.target == drieknop){ cardlayout.show(rechterpaneel,"kaart 3"); return true; return false; na het intikken van deze code zult u de werking kunnen zien Ander componenten Met het gebruiken van de lay-out vormen zijn er nog andere componenten die we gaan gebruiken. Een paar van deze componenten gaan we hierna uitvoeriger bespreken check box public class checkbox extends Applet { private Checkbox rood, geel, grijs; public void init(){ rood = new Checkbox("rood"); geel = new Checkbox("geel",null,true); grijs = new Checkbox("blauw"); add(rood); add(geel); add(grijs); public void paint(graphics g){ int midden = bounds().width/2; // bepalen van het midden: int midden = getbounds().width/2 if(rood.getstate()){ g.setcolor(color.red); Java 98

99 g.fillrect(midden - 60, 50, 40, 150); if(geel.getstate()){ g.setcolor(color.yellow); g.fillrect(midden - 20, 50, 40, 150); if(grijs.getstate()){ g.setcolor(color.blue); g.fillrect(midden + 20, 50, 40, 150); public boolean action(event e, Object o){ if(e.target instanceof Checkbox){ repaint(); return true; return false; wat opvalt in dit voorbeeld is het gebruik van de operator instanceof. Naarmate het aantal componenten toeneemt, is het overzichtelijker om bij het afhandelen van een event eerst te controleren in welk soort component de event heeft plaats genomen. Betreft het een knop, of en selectievakje enz. de operator instanceof heeft 2 operanden. If(e.target instanceof Checkbox) In dit geval zullen we kijken als e.target een instantie is van de checkbox, zo ja geeft dit true ander natuurlijk false. Bij het kijken naar verschillende objecten van de zelfde soort moet men er acht op slaan welk een object men aanspreekt bijvoorbeeld: If(e.target instance of Button){ If(e.target == b1){ // alles wat bij b1 hoort if(e.target == b1{ //alles wat bij b2 hoort Bij een checkbox hebben we twee mogelijkheden, het is aangevinkt of niet. We onderzoeken dit met de methode getstate() deze is true bij aangevinkt en anders false Radioknoppen een checkboxgroep Java 99

100 public class radioknoppen extends Applet { private CheckboxGroup radiogroep; private Checkbox rood, geel, blauw; public void init(){ radiogroep = new CheckboxGroup(); rood = new Checkbox("Rood",radioGroep, true); geel = new Checkbox("Geel",radioGroep,false); blauw = new Checkbox("Blauw",radioGroep,false); add(rood);add(geel);add(blauw); public void paint(graphics g){ if(rood.getstate()) g.setcolor(color.red); else if(geel.getstate()) g.setcolor(color.yellow ); else if(blauw.getstate()) g.setcolor(color.blue); int midden = bounds().width/2; g.fillrect(midden-20,50,40,150); public boolean action(event e, Object o){ if(e.target instanceof Checkbox){ repaint(); return true; return false; men moet er vooral opletten dat men eerst een instantie maakt van de klasse checkboxgroup. Radiogroep = new CheckboxGroup(); Daarna maak je het vakje die je wilt functioneren met een constructor met 3 argumenten waarin het tweede de naam is van de instantie van de checkbox groep en de derde als hij al dan niet is aangeduid keuzelijst. Met deze gebruikt men het additem() methode om een onderwerp toe te voegen aan de lijst. Java 100

101 public class choicelist extends Applet { private Choice kleurenlijst; private String welkekleur; public void init(){ // maak een keuze lijst en voeg toe kleurenlijst = new Choice(); kleurenlijst.additem("rood"); kleurenlijst.additem("geel"); kleurenlijst.additem("zwart"); add(kleurenlijst); public void paint(graphics g){ if("rood".equals(welkekleur)) g.setcolor(color.red); else if("geel".equals(welkekleur)) g.setcolor(color.yellow); else if("zwart".equals(welkekleur)) g.setcolor(color.black); int midden = bounds().width/2; g.fillrect(midden-20,100,40,150); public boolean action(event e, Object o){ if(e.target instanceof Choice){ welkekleur = (String) o; repaint(); return true; return false; oefening1.maak een rekenmachine volgens onderstaande figuur. Men moet enkel kunnen optellen. Java 101

102 2. maak van volgende vorig geziene oefeningen een voorstelling met een gepaste lay-out vorm Oefening bij deel 27 over het maken van Romeinse cijfers. 3. maak een Applet met een lay-out vorm. Gebruik het component checkbox om een bepaalde tekst die men ingevoerd heeft van font te doen veranderen. Gebruik hiervoor een keuze lijst met 3 Fonts Maak door gebruik te maken van radioknopen ook het kleur van de teksten veranderbaar. Gebruik daarvoor 2 kleuren (rood en blauw). Let wel de originele kleur moet zwart zijn. 4. Tracht de gekende bewerkingen -,*,/ te implementeren in de oefening 1. Java 102

103 Hoofdstuk 17. Ontwerpen van applicaties We hebben ons in vorige lessen hoofdzakelijk bezig gehouden met Applet s. Applet s worden gedragen door een uitwendige structuur met namen de browser van uw operating systeem( IE, Netscape ). Het is natuurlijk ook volstrekt mogelijk om in Java op zichzelf staande programma s te maken. Dat wil zeggen programma s die niet gedragen worden door een uitwendig systeem. We kennen twee soorten applicaties: - applicaties die invoer en uitvoer van tekst gebruiken; - applicaties die vensters en widgets gebruiken. Programma s geschreven in het eerste type gedraagt main als de sturende methode (de naam laat het zich al vermoeden) van het programma. Het heeft de totale controle over het geheel en creëert en roept objecten aan indien nodig. Een kleine vergelijking bestaat bijvoorbeeld met het vroeger geleerde programma Pascal in het hoofd procedure (Begin.End.) van het programma. Als het programma beëindigd is zal main stoppen. Programma s geschreven met de andere methode, die dus vensters met AWT speelt zich dit enigszins anders af. In dit geval zal de methode main een tijdelijke rol vervullen, bij het initiëren van de objecten. We kunnen een gelijkenis treffen met de al gekende init methode in de Applet s die voorheen schreven. Deze zal ook de widgets objecten opzetten en vervolgens stopt. Wat er ook zij het voornaamste en eerste werk dat deze methode main doet is een handig object creëren en vervolgens methodes daarin oproept. De werking is als volgt. Het eerste object door main gemaakt is een instantie van de klasse waarin main zelf een static methode is. En de methode die dat aanroept is een andere methode in de zelfde klasse. Het is een ingewikkelde uitleg maar onderstaand schema zal het denkelijk een, beetje vereenvoudigen: - het OS roept binnen de klasse Applicatie een static methode aan met de naam main - de methode main creëert een instantie van de klasse Applicatie - de methode main roept een methode van het object aan Bekijken we eens een voorbeeld: In dit eerste voorbeeld gaan we een oefening her opnemen dat we vroeger al gemaakt hebben namelijk de oefening van de groeiballon. We hadden deze gemaakt als Applet en nu gaan we dit eens proberen om te vormen als applicatie. In de moderne toepassingen wordt er veelal gebruik gemaakt van vensters, schuifbalken knoppen enz. We hebben dat in vorige oefeningen veel gebruikt in grafische gebruikers interfaces en dergelijke. Nu zult u zeker opmerken dat dit Applet s waren. Applicaties achter zijn daarin niet anders en gebruiken ook de AWT daarvoor (Abstract Windows Toolkit). Natuurlijk zijn er een paar verschillen. Volgende code geeft groeiballon in een op zichzelf staande applicatie Java 103

104 package testenappli; import javax.swing.uimanager; import java.awt.*; import java.awt.event.*; class Ballon{ private int diameter; private int xcoord, ycoord; public Ballon(int idiameter, int ix, int iy){ diameter = idiameter; xcoord = ix; ycoord = iy; public void Verander (int verandering){ diameter = diameter + verandering; public void teken(graphics g){ g.drawoval(xcoord, ycoord, diameter, diameter); public class Ballonnen extends Frame implements ActionListener, WindowListener{ private Button groei, krimp; private Ballon ballon; public static void main(string[] args){ Ballonnen f = new Ballonnen(); f.setsize(300,300); f.setvisible(true); public Ballonnen(){ settitle("ballon"); setlayout(new FlowLayout()); groei = new Button("groei"); add(groei); groei.addactionlistener(this); krimp = new Button("krimp"); add(krimp); krimp.addactionlistener(this); ballon = new Ballon(20,50,50); this.addwindowlistener(this); public void actionperformed(actionevent event){ if (event.getsource() == groei){ ballon.verander(10); if (event.getsource() == krimp){ ballon.verander(-10); repaint(); Java 104

105 public void windowclosing(windowevent event){ System.exit(0); public void windowiconified(windowevent event){ public void windowopened(windowevent event){ public void windowclosed(windowevent event){ public void windowdeiconified(windowevent event){ public void windowactivated(windowevent event){ public void windowdeactivated(windowevent event){ public void paint(graphics g){ ballon.teken(g); Figuur 60 Laat ons nu even uitleggen hoe we nu een Applet omgevormd hebben naar een applicatie. Als je een Applet programmeert dan breid je in feite de bibliotheek klasse Applet uit. Dat hebben we in vorig deel uitvoerig besproken. Daardoor is er automatisch een venster gebied voorhanden. In tegenstelling met applicatie met deze als hij een venster gebruikt die zelf creëren. Zo iets wordt dan frame genoemd. De gemakkelijkste manier daarvoor is door overerving (zie eerste deel) uit de bibliotheek klasse Frame. Een Applet wordt gewoonlijk met een webpagina aan gesproken, en het venster heeft geen titel balk en titel. Om dit te laten verschijnen in onze applicatie roepen we aan met settitle( ). Daaraan koppelen we de naam als parameter erbij. Voor widgets toe te voegen aan het frame gebruiken we en soort lay-out met het commando setlayout(new FlowLayout). Deze specifieke lay-out zorgt er voor dat de widgets van links naar rechts verschijnen op de balk. Dit in de volgorde dat het programma de methode add aanroept. Er zal indien nodig een nieuwe rij gevormd worden. Als volgende punt laat ons eens kijken hoe het programma afsluit. Bij onze Applet worden het programma afgesloten als we de ondersteuning wegnemen. Bijvoorbeeld als we de browser sluiten. Nu echter moeten we daar zelf voor zorgen Dit doen we met de methode windowclosing. Doordat de applicatie op het moment van het oproepen volledig de baas is moeten we er voor Java 105

106 zorgen dat het afsluiten van zichzelf een van de taken is war dat programma moet voor zorgen. Een event gebeurt steeds als er iets gebeurt, zoals het klikken op het kruisje rechts boven. Bij een event handeling is de eerste stap het aanmelden van de Listener voor die event. Hier kunnen we dat als volgt regelen: This.addWindowListener(this). Een andere manier is gewoon met een stop knop. Deze moet er voor zorgen dat de methode Systeem.exit(0) Applicaties met Jbuilder Zoals we hiervoor gezien hebben is bij het maken van applicaties veel gelegen aan het uitzicht. Daar we gebruikmaken van een sterke editor omgeving, nl. Jbuilder van Borland, zijn we in het bezit van veel mogelijkheden om een mooi uitzicht te geven aan onze applicatie. Zoals we al ondervonden hebben met de Visual Basis omgevingen kunnen we ook in Java dezelfde structuur handhaven. In Java echter noemt dat beans Wat is een Bean? Een Bean in Java wordt gedefinieerd door zijn structuur. Het volgt verschillende regels van ontwerp en gebruik. Sommige Java Compilers zijn in het bezit van mogelijkheden om dit alles te ondervangen en al te programmeren. Het zelfde hebben we inderdaad in Visual Basic. JBuilder, die we hier gebruiken, is één van die programma s. Een bean moet weten hoe hij gebruik moet maken van events. Als bijvoorbeeld iets gebeurt moet de bean in de mogelijkheid zijn om deze gebeurtenis (event) naar behoren af te handelen. Een bean moet ook visueel te configureren zijn. Zo een programma moet ook de mogelijkheid hebben te worden bewaard en terug herbruikt worden Eigenschappen, methoden en gebeurtenissen Als we een bean op ons canvas plaatsen is het eerste wat we in orde brengen de eigenschappen (properties). Men noemt ook een eigenschap van en bean het attribuut van deze bean. Het volgende die we bekijken zijn de methoden. De methoden geven de mogelijkheid om de bean te behandelen De methoden (methodes) zijn ons al langer bekend. De builder tool geeft ons de kans om allen publieke methoden (public) te gebruiken van het bean of het gebruiken van de subset als men gebruik maakt van de restrict access. Dan hebben we ook nog de gebeurtenissen (events). Een gebeurtenis is een actie die men eventueel met het bean kan uitoefenen. Als een bean 36.3 het gebruik van een GUI Jbutton, JradioButton,Jtogglebutton,JCheckBox, Jlabel,JTextField, JTextArea, listveld, Java 106

107 Als test gaan we een nieuw project openen. Daarin openen we een applicatie. We gebruiken nu het design gedeelte van onze jbuilder programma. Eigenschappen(properties) Zoals je ziet voegen we daarin een tekst veld, dit noemen we jtextfield1, en twee knoppen genaamd eerst btnadd en btnverwijder. Tussen de twee knoppen maken we een list veld. Deze onderwerpen vind men bovenaan de UI. In de properties kunnen we de verschillende eigenschappen invullen. Als we deze tekening gemaakt hebben gaan we naar het tabblad source. Daarin kunnen we zien dat al de volledige code vooraf gemaakt is. Laten we deze applicatie even tot leven brengen. Daarom moeten we op bepaalde plaatsen in de code verandering aan brengen. Laat ons eerst even de code bestuderen: Java 107

108 Door in de eigenschappen Frame1 te veranderen in oefening 1 geven we aan ons oefening een beduidende naam, dit kan ook gedaan worden in de eigenschappen van het frame. Bij de events is voor ons de belangrijkste het Listener event. Immers er moet iets gebeuren als we op een knop drukken. Wat we ook dienen toe te voegen, en dat opdat het component jlist1 dynamisch zou worden: Private void jbinit() throws Exception { ++++ ListModel model = new DefaultListModel(); jlist1.setmodel(model); Om te zorgen dat er een tekst in de listbox( midden van scherm) verschijnt moeten we de voegtoe knop (btnadd) een actie toe bedelen. Dat gebeurt door volgende lijnen in de source code toe te voegen: void btnadd_actionperformed(actionevent e) { String s = jtextfield1.gettext(); if(s.length()>0){ DefaultListModel model = (DefaultListModel)jList1.getModel(); model.addelement(s); De tweede knop krijgt een code die bijna hetzelfde is. Wat we moeten voorzien is dat in de plaats van het bijvoegen van een element (addelements), We er moeten opdenken om het element te verwijderen. void btnverwijder_actionperformed(actionevent e) { String s = jtextfield1.gettext(); if(s.length()>0){ DefaultListModel model = (DefaultListModel)jList1.getModel(); model.removeelement(s); Figuur 61 Java 108