Programmeren met Java kopie

Programmeren met Java kopie

A Inleiding

Vooraf

In deze interactieve module maak je kennis met de programmeertaal Java. De taal Java is ontwikkeld door James Gosling. De naam Java is pas later bedacht. Gosling noemde zijn nieuwe programmeertaal aanvankelijk “Oak”. Vanuit zijn kantoor keek Gosling door het raam uit op een eikenboom. De naam Oak werd jaren later door Sun, het bedrijf waar Gosling werkte, veranderd in Java, omdat de naam al was geregistreerd door een ander bedrijf, Oak Technologies. In 2010 is Sun overgenomen door Oracle.

Java werkt met een bibliotheek van klassen. Elke klasse bevat een stukje kant en klare code. Een programmeur kan in zijn eigen programma gebruik maken van één of meerdere bestaande klassen. De programmeur hoeft dan niet telkens alle code zelf te schrijven, maar kan slim gebruik maken van voorgeprogrammeerde klassen. En dat scheelt een hoop tijd.

Leerdoelen

Na verwerking van deze module:

  • kun je uitleggen wat een computerprogramma is;
  • kun je uitleggen wat een algoritme is;
  • kun je uitleggen wat het verschil is tussen broncode en machinecode;
  • kun je uitleggen wat de functie van een compiler is;
  • kun je het verschil uitleggen tussen een aantal belangrijke basisstructuren voor het beschrijven van algoritmen (opeenvolging, keuze en herhaling);
  • kun je eenvoudig visueel programmeren in Java;
  • weet je welke regels er worden toegepast bij het geven van namen in Java;
  • weet je wat reserved words zijn;
  • kun je verschillende typen variabelen uit Java herkennen en gebruiken;
  • kun je uitleggen wat het verschil is tussen de declaratie en initialisatie van een variabele;
  • weet je wat een toekenning (assignment) is;
  • kun je het verschil uitleggen tussen een statement (opdracht) en een samengesteld statement;
  • kun je een aantal voorbeelden van herhaling en keuze in Java beschrijven;
  • kun je het verschil tussen primitief type en referentietype aangeven;
  • kun je de begrippen klasse, object en methode uitleggen en gebruiken;
  • kun je de regels voor conversie toepassen;
  • kun je een aantal methoden uit Java gebruiken;
  • weet je wat het verschil is tussen een lokale variabele en instance variabelen;
  • kun je de klasse String toepassen bij het programmeren van applets.

Bijlagen

Zo werkt het

Je bent begonnen in de module Programmeren met Java.
Deze module bestaat uit meerdere onderdelen.
In ieder onderdeel vind je, verdeeld over verschillende pagina's, informatie in de vorm van teksten, afbeeldingen en video's.

Daarnaast ga je zelf aan de slag. Onder het kopje "Aan de slag" vind je steeds toepassingsopdrachten. Deze opdrachten maak je alleen of met een klasgenoot.

Er zijn ook toetsen. Deze herken je aan de blauwe knop met daarop "Adaptieve Toets". Een toets bestaat uit meerdere vragen. Dat kunnen gesloten vragen zijn, die door de computer worden nagekeken, of open vragen, die je zelf moet nakijken. Bij een enkele vraag moet je een bestand uploaden.

Van de toetsen wordt, als je ingelogd bent, de voortgang bijgehouden.
Het resultaat vind je onder de knop "Voortgang". Deze voortgang is ook door je docent te bekijken.

Succes met de module Programmeren met Java.

B Visueel programmeren

Computerprogramma

Computerprogramma’s worden geschreven door programmeurs. Een computerprogramma bestaat uit een reeks instructies die door een computer worden uitgevoerd. De programmacode die wordt geschreven, heet de broncode. Deze broncode kan niet rechtstreeks door een computer worden verwerkt. De broncode moet eerst worden omgezet naar uitvoerbare code. Daarna kan het programma pas worden gerund. Het proces van het omzetten van broncode naar uitvoerbare code verloopt, afhankelijk van de gebruikte programmeeromgeving, niet altijd op dezelfde manier.

In Java wordt de broncode van het programma geschreven in voor mensen leesbare platte tekst. Met platte tekst bedoelen we tekst zonder codes voor opmaak van de tekst. De broncode wordt opgeslagen in een bestand met de extensie .java. Daarna moet dit bestand worden omgezet naar een formaat dat door de computer kan worden verwerkt. Daarvoor wordt een apart programma, de compiler, gebruikt. Een compiler zet broncode om naar machinetaal zodat deze uitgevoerd kan worden. In Java levert het compileren van de broncode een .class bestand op. Dit bestand bevat Java bytecode.
 

Deze bytecode is echter geen volwaardige machinecode en kan dan ook niet rechtstreeks worden uitgevoerd. Het is een soort tussenvorm. De code is, in tegenstelling tot machinecode, processoronafhankelijk. Er is een speciaal geschreven programma nodig om de bytecode op een bepaald platform uit te voeren. Dat programma heet Java Virtual Machine.

Om Java thuis op je computer te kunnen draaien, moet vooraf de Java Development Kit (JDK) geïnstalleerd worden. In een van de bijlagen beschrijven we waar je deze JDK kunt downloaden en hoe je deze software kunt installeren.

Algoritmen - 1

Stel we willen het spelletje boter, kaas en eieren programmeren. Voordat we daadwerkelijk programmacode gaan schrijven, moeten we eerst goed nadenken over wat we precies moeten programmeren. Daarvoor stellen we een stappenplan op waarin beschreven wordt hoe we het gewenste einddoel, het spelletje, kunnen realiseren. De beschrijving van de stappen die moeten worden doorlopen om een bepaald doel te bereiken, noemen we een algoritme.
 

★ Aan de slag 1

Ontwerp een algoritme voor het spelletje boter, kaas en eieren. Bedenk daarbij dat er twee mogelijkheden zijn: jij begint met spelen of de tegenstander begint met spelen.

Algoritmen - 2

Voor het beschrijven van algoritmen wordt gebruik gemaakt van basisstructuren. Drie belangrijke basisstructuren zijn:

  1. De opeenvolging (sequentie).
  2. De keuze.
  3. De herhaling.
  1. Bij de opeenvolging is er sprake van een reeks opdrachten die na elkaar worden uitgevoerd.
  2. Bij een keuze wordt eerst bekeken of aan een bepaalde voorwaarde wordt voldaan voordat een opdracht wordt uitgevoerd, bijvoorbeeld cijfer >= 6. Als het cijfer 6 of hoger is klopt deze vergelijking: true, anders klopt deze vergelijking niet: false. Zo’n voorwaarde wordt een logische expressie genoemd.
  3. Bij een herhaling wordt een reeks opdrachten uitgevoerd zolang of totdat er aan een bepaalde voorwaarde wordt voldaan, bijvoorbeeld teller <= 10.

★ Aan de slag 2

Bij een herhaling kan worden gekozen voor een zolang- of een totdat-opdracht. Wat is als je kijkt naar de uitvoering van de stappen een belangrijk verschil tussen de zolang- en de totdat-opdracht?

 

IDE

Voor het programmeren van een computerprogramma kun je volstaan met een eenvoudige editor zoals Notepad++. Om het programma uit te voeren heb je dan nog wel een compiler of interpreter nodig. Het verschil tussen een compiler en een interpreter is dat een interpreter de broncode regel voor regel omzet in machinecode. De broncode wordt gelijk uitgevoerd. Een compiler zet eerst alle broncode om naar machinecode waarna de code door de computer uitgevoerd kan worden.

Moderne programmeeromgevingen hebben een uitgebreide user interface met menu's, knoppen, invulvelden en animaties. Voor het schrijven van een simpele user interface moet er al veel programmacode worden ingetypt: veel en niet zo interessant werk. Daarom zijn er zogenaamde geïntegreerde ontwikkelomgevingen (IDE: Integrated Development Environment) op de markt gebracht. Deze IDE’s verlichten het werk van de programmeur. Zo kan er in Java gebruik gemaakt worden van de bestaande klassenbibliotheek waar al eerder over gesproken is. De programmacode voor het schrijven van de user interface wordt door de IDE voor de programmeur aangeleverd en hoeft niet telkens zelf te worden geschreven.

Er zijn verschillende IDE's op de markt waarvan wij er een gebruiken: JavaEditor. Het gaat te ver om JavaEditor in al zijn details te behandelen. In dit onderdeel laten we je zien hoe je een programma met een eenvoudige interface kunt maken. Een programma kan in Java worden uitgewerkt als een applet of een applicatie. In deze module werken we met applets. In een van de bijlagen bij deze module bespreken we het verschil tussen een applet en een applicatie.

★ Aan de slag 3

  1. Wat is het grote voordeel van een geïntegreerde ontwikkelomgeving boven een “ouderwetse” editor?
  2. Beschrijf de taak van een compiler in een geïntegreerde ontwikkelomgeving.

JavaEditor

Werken met JavaEditor
Wanneer je JavaEditor opstart, krijg je het scherm hieronder te zien.

 

Een nieuw project start je op met
Bestand → Nieuw → Applet
of door op de knop Applet te klikken.

Het programmavenster van JavaEditor bestaat uit een aantal onderdelen:

  • de menubalk.
  • de knoppenbalk of symboollijst.
  • De Object-inspecteur geeft een overzicht van de eigenschappen en de huidige waarden van een object (bijvoorbeeld een knop). Het venster van de Object-inspecteur kan in Windows uit- of aangezet worden met de toetsencombinatie Ctrl + I of door in de menubalk bij Venster te klikken op Object-inspecteur aan/uit.
  • Hieronder zie je de editor: een venster met Java-code.

★ Aan de slag 4

Open JavaEditor en start een nieuw project op (Bestand → Nieuw → Applet). JavaEditor vraagt je om een naam te geven aan het applet.

  1. Maak eerst een map EersteApplet aan.
  2. Geef het applet de naam EersteApplet.
  3. Sla het applet op in de map EersteApplet.

★ Aan de slag 5

Het eerste applet

Hieronder leggen we stap voor stap uit hoe je je eerste applet maakt. Doorloop nu zelf alle stappen om het EersteApplet te maken.

We gaan een programma schrijven waarvan de interface bestaat uit twee tekstvelden en een knop. In het eerste tekstveld typt de gebruiker zijn naam in. Het klikken op de knop heeft als resultaat dat de ingevoerde naam in het tweede tekstveld wordt geplaatst. Het eerste tekstveld wordt weer leeggemaakt.

We beginnen met het maken van de user interface. We maken daarbij gebruik van het hulpmiddel dat JavaEditor ons biedt: het designformulier.

  1. In het designformulier moeten twee tekstvelden geplaatst worden: een voor de invoer en een voor de uitvoer. In de symboollijst van JavaEditor is daar een aparte knop voor.

Klik in de symboollijst op het tabblad AWT en vervolgens op de knop TextField.

  1. Plaats een tekstveld in het designformulier door een rechthoek te trekken.
  2. Plaats het tweede tekstveld op dezelfde manier.
  3. Vervolgens plaatsen we een knop in het designformulier. Klik daarvoor op de knop Button in de knoppenbalk en plaats de knop in het designformulier.



    Dan verschijnt het volgende scherm:
  4. Op de knop staat standaard de tekst “button‟. We willen natuurlijk een tekst geven die duidelijk maakt wat de functie van de knop is. Dergelijke kenmerken van een object kunnen we wijzigen in de Object-inspecteur. Selecteer de knop door er op te klikken. In de Object-inspecteur verschijnen de kenmerken (attributen) van de knop. Daarin wordt bijvoorbeeld het lettertype van de knop (font), de positie en grootte van het knop, de tekst op de knop (label) en de naam van de knop (name) getoond.

    Wijzig het label van de knop in Verplaats.
  1. De naam die JavaEditor aan de knop heeft gegeven is button1. Wanneer we meerdere knoppen gebruiken in een applet is aan de naam niet af te lezen welke knop bedoeld wordt. Daarom moet ieder object van een betekenisvolle naam worden voorzien.
    Wijzig de naam van de knop in verplaatsKnop.
    Let daarbij op het gebruik van hoofdletters en kleine letters. Java ziet dat als verschillende tekens. De naam van een object begint met een kleine letter. Het type object, in dit geval knop, schrijven we met een hoofdletter.
  2. Wijzig op dezelfde manier de naam van het bovenste tekstveld in invoerVeld en het onderste tekstveld in uitvoerVeld. Verwijder de tekst in het vak Text.
  3. Het ontwerp van de user interface is klaar. Het applet kan proefdraaien. Daarvoor bezit JavaEditor een interpreter: de Applet Viewer. Uiteindelijk als het applet klaar is, kan het ook in een browser draaien.
    Om het applet te testen kies: Start → Starten.
    Typ in het invoerveld je naam en klik op de knop Verplaats.
    In het uitvoerveld verschijnt niets. We hebben wel keurig de velden en de knop geplaatst, maar nog niet aangegeven wat het applet moet doen als er op de knop gedrukt wordt. Het klikken op de knop noemen we een event (een gebeurtenis). De gebruiker wil het programma iets laten doen. Daarvoor moet er een stukje programma worden geschreven, dat de event afhandelt. Dat stukje code noemen we een event-handler (het afhandelen van een event).
  1. Sluit de Applet Viewer af.
  2. Om het applet te laten reageren op de verplaatsknop, moet er een programmacode worden toegevoegd. Daarvoor maken we gebruik van de editor in JavaEditor.


    In het venster staat de code al. Dit is de code (blauw en zwart gekleurd) die JavaEditor gemaakt heeft op het moment dat je een tekstveld of een knop in het designformulier plaatste. We gaan nu nog niet in op de betekenis van die code.
    Om de verplaatsknop iets te laten doen moeten we de event-handler voor de knop toevoegen. Deze code moet de tekst uit het invoerveld halen, die tekst in het uitvoerveld zetten en het uitvoerveld leegmaken.
    Onder aan de programmacode staat de event-handler van de verplaatsKnop.

    // Begin eventmethoden
    public void verplaatsKnopActionPerformed(ActionEvent evt) { }

    Tussen de accolades typ je de programmacode in die op de volgende pagina staat. Denk eraan dat je de code letterlijk overneemt. Let daarbij op het gebruik van hoofdletters en de leestekens.

// De tekst in het invoerVeld wordt verplaatst naar het uitvoerVeld.
String naam;
naam = invoerVeld.getText();
uitvoerVeld.setText(naam);
invoerVeld.setText("");

  1. Wat betekent de code?
    De eerste regel is commentaar. Commentaar is bedoeld om de code beter leesbaar te maken voor de programmeur. In Java kun je commentaar toevoegen door tekst achter // te plaatsen of tussen /* en */. In de tweede regel wordt de variabele naam gecreëerd van het type String. In deze variabele kan tekst worden opgeslagen. In de derde de regel wordt de inhoud van het invoerveld met behulp van de methode getText() opgeslagen in de variabele naam. In regel vier wordt de inhoud van de variabele met behulp van de methode setText() in het uitvoerveld geplaatst. In de laatste regel wordt het invoerveld leeg gemaakt.
  2. Test het applet nu nog een keer en kijk of alles werkt.
  3. Als laatste stap moet je het applet bewaren in de vorm van een project.
    Kies Bestand → Als project opslaan.
    Geef het project de naam EersteAppletProject.

★ Aan de slag 6

  1. Beschrijf in eigen woorden wat een event-handler is.
  2. Hoe kun je in Java in de programmacode commentaar aangeven?

 

★ Aan de slag 7

Hiernaast zie je de object-inspecteur van het invoerVeld. Met de object-inspecteur kun je een aantal eigenschappen (attributen) van de objecten op het applet aanpassen.

  1. Pas de volgende attributen van het invoerVeld aan:
    achtergrond: grijs
    hoogte: 40
    breedte: 250
  2. Zorg ervoor dat het label op de verplaatsKnop vet wordt afgebeeld.
  3. Pas de attributen van het uitvoerVeld aan:
    achtergrond: geel
    editable: false
    font: letterkleur blauw en grootte 20
    hoogte: 40
    breedte: 250
  4. Wat gebeurt er als je het attribuut editable wijzigt?
  5. Sla alle wijzigingen op.

★ Aan de slag 8

Maak een applet met twee knoppen: FUN en BORING.
Geef de knoppen de namen funKnop en boringKnop. De vraag staat in een Label: “Wat vind je van Java?”
Wanneer de gebruiker op de knop FUN klikt, dan moet in het label de tekst “Java is fun !!” verschijnen. Wanneer de gebruiker op de knop BORING klikt verschijnt in het label de tekst “Java is boring.” De tekst in het label moet worden afgedrukt in een lettergrootte 30, vet. Geef het label de naam meningLabel. De tekst op de knoppen moet vet worden afgedrukt.

★ Aan de slag 9

NawApplet
De opdracht is een applet te maken, waarin de gebruiker achtereenvolgens zijn naam, adres en woonplaats in aparte tekstvelden typt. Om duidelijk te maken wat er moet worden ingetypt, staan er labels bij de invoervelden. In de popup hieronder staat een voorbeeld.

In een tekstveld kan slechts één regel geplaatst worden. Door de gebruiker te laten klikken op een OK knop, moet de tekst uit de invoervelden verzameld worden en in een apart veld met meerdere regels onder elkaar worden gezet. Daarvoor gebruik je een TextArea, want een TextArea kan meerdere regels tekst bevatten.

  1. Open een nieuw applet en sla het applet op onder de naam NawApplet in een nieuwe map NawApplet
  2. Plaats drie maal een TextField en geef deze objecten de namen naamVeld, adresVeld en woonplaatsVeld
  3. Plaats een Button met de tekst OK en noem dit object okKnop
  4. Plaats voor de drie objecten van de klasse TextField drie Labels.
  5. Wijzig de naam van het eerste label in naamLabel
  6. Wijzig de tekst van het label in: Typ je naam in:
  7. Maak op dezelfde manier ook een adresLabel en een woonplaatsLabel
  8. Maak een TextArea voor de tekst uit de drie invoervelden en geef het object de naam uitvoerArea
  9. Om het applet te laten reageren op de okKnop moet er de nodige programmacode gekoppeld worden aan die knop: de event-handler van de okKnop Gebruik daarvoor de programmacode die in de hieronder staat.
    programmacode

Je moet nu in staat zijn de programmacode te begrijpen.
Alleen in regel 8 staat iets nieuws: “\n”
Deze code zorgt ervoor dat wanneer het applet wordt uitgevoerd een harde return wordt geplaatst.
Een harde return zorgt ervoor dat er op een nieuwe regel verder kan worden gegaan.

Met het plusteken in regel 8 worden twee strings aan elkaar gekoppeld.
In deze opdracht wordt de variabele naam gekoppeld aan de harde return, daaraan het adres enz.

  1. Bewaar het applet in de vorm van een project.
    Kies Bestand → Als project opslaan. Geef het project de naam NawProject
  2. Test het programma.

★ Aan de slag 10

In de vorige opdracht hebben we code voor de event-handler van de opKnop geschreven (NawApplet). We gaan die code nader analyseren. Daarvoor moet je de volgende vragen beantwoorden:

  1. Wat gebeurt er in de regel String naam; ?
  2. Wat doet de methode getText() in de regel naam = naamVeld.getText(); ?
  3. Waarom moet je een object van de klasse TextArea gebruiken in plaats van de klasse TextField?
  4. In regel 8 staat uitvoer = naam + "\n" + adres + "\n" + woonplaats;
    Leg uit wat de code in regel 8 doet. Gebruik bij je uitleg "\n" en =.
  5. Wat gebeurt er in de regel uitvoerArea.setText(uitvoer); ?

★ Aan de slag 11

Het applet EersteApplet heeft nog de standaardkleuren en lettertypen. Om die te wijzigen maak je in eerste instantie gebruik van de Object-inspecteur. Daarmee kun je bijvoorbeeld de achtergrondkleur of het lettertype van een TextField wijzigen.

  1. Wijzig de achtergrondkleur van het invoerVeld in YELLOW.
    In de code van het EersteApplet is een regel toegevoegd. Die aanpassing staat in een methode die de instellingen van het applet bepaalt: de methode init(). Daar is de regel invoerVeld.setBackground(Color.YELLOW); toegevoegd.

Java kent 10 standaardkleuren: BLACK, CYAN, GRAY, GREEN, MAGENTA, ORANGE, PINK, RED, WHITE, YELLOW. Daarnaast kun je zelf kleuren creëren volgens het RGB-systeem.

  1. Wijzig de kleur van het lettertype van het invoerVeld in BLUE.
  2. Welke regel is er toegevoegd aan de methode init()?

De achtergrondkleur van het applet kun je niet wijzigen met behulp van de Object-inspecteur. In dat geval moet je zelf code toevoegen aan de methode init() Wanneer je de achtergrondkleur van het applet wilt wijzigen in BLUE, dan vind je de code daarvoor op de derde regel.

public void init() {
Panel cp = new Panel(null);
cp.setBounds(0, 0, 300, 300);
cp.setBackground(Color.BLUE);
add(cp);
 

  1. Wijzig de achtergrondkleur van het applet in BLUE.
  2. Wijzig de achtergrondkleur van de verplaatsKnop in RED en de kleur van de letters in YELLOW.
  3. Welke regels heb je toegevoegd aan de methode init()?
  4. Pas de achtergrondkleur en de kleur van het lettertype voor het uitvoerVeld aan.
  5. Test het applet.
  6. Sla het project op.

★ Aan de slag 12

In het invoerveld kan een gebruiker van het applet tekst intypen en wijzigen. In het uitvoerveld is dat ook mogelijk. Dat is niet de bedoeling. Dit kan voorkomen worden door de volgende regel code aan de methode init() toe te voegen:
uitvoerVeld.setEditable(false);
Sla de wijzigingen op.

★ Aan de slag 13

In dit applet kan de gebruiker de kleur en de positie van de knoppen wijzigen door op een knop te klikken.
De methode om de positie (en de grootte) van de knop te wijzigen is
setBounds(xpos,ypos,b,h);
Bijvoorbeeld: roodKnop.setBounds(10,30,100,40);

  1. Open een nieuw applet en sla het applet op onder de naam KleurenApplet in de een nieuwe map KleurenApplet.
  2. Plaats de twee knoppen op het applet.
  3. Pas de kleuren van het applet en de knoppen aan.
  4. Schrijf de event-handlers voor de roodKnop en de blauwKnop
  5. Bewaar het applet in de vorm van een project het project.
    Kies Bestand → Als project opslaan.
    Geef het project de naam KleurenProject.
  6. Test het programma.

C Code nader bekeken

Toekenning - expressie

In het EersteApplet staat het volgende stukje programmacode:

String naam;
naam = invoerVeld.getText();

Bekijk deze code eens wat beter. De tweede regel is een voorbeeld van een toekenning, in het Engels assignment.
Aan de rechterkant van de “=” staat een zogenaamde expressie, waarvan de waarde wordt toegekend aan de variabele aan de linkerkant van de “=”. Variabelen zijn geheugenplaatsen.
Een toekenning heeft altijd de volgende vorm:

variabelnaam = expressie;

In regel twee is de expressie invoerVeld.getText() De waarde van deze expressie is de tekst die we hebben ingetypt in het tekstveld invoerVeld Deze waarde wordt toegekend aan de variabele naam.

Namen in Java

In Java moeten namen aan vaste regels voldoen:

  • Namen bestaan uit letters en cijfers. Java maakt daarbij een onderscheid tussen hoofdletters en kleine letters.
  • Een naam moet met een letter beginnen.
  • Niet alle woorden mogen gebruikt worden als naam voor een variabele. Bepaalde woorden, als int en while, hebben in Java een speciale betekenis. Die woorden heten reserved words.

Daarnaast worden er afspraken gemaakt over het geven van namen, waar iedere goede programmeur zich aan houdt:

  • Namen van klassen beginnen met een hoofdletter:
    EersteApplet
    RenteApplet
  • Namen van objecten laten we beginnen met een kleine letter. De naam moet zo gekozen zijn dat het duidelijk aangeeft wat de inhoud van het object is:
    adresVeld
    annuleerKnop
  • Wanneer een naam uit twee of meer woorden bestaat dan worden de volgende woorden met een hoofdletter vast aan het vorige woord geschreven:
    EersteApplet
    invoerVeld

Declaratie - initialisatie

Een variabele is altijd van een bepaald type. Je kunt niet zomaar iedere waarde toekennen aan een variabele. Er zijn variabelen die tekst bevatten, maar ook variabelen die alleen een geheel getal of een reëel getal kunnen bevatten. Het geven van een naam en een type aan een variabele gebeurt in een declaratie.

Kijk nog eens naar het voorbeeld:

String naam;
naam = invoerVeld.getText();

Er wordt aan de variabele naam een tekst toegekend. De variabele is van het type String. Een waarde van het type “String” is een tekst. In de eerste regel is in een declaratie vastgelegd dat de variabele “naam” een bepaalde naam heeft en van een bepaald type is.
De naam van een variabele kan in principe vrij worden gekozen, maar het type niet. In Java bestaat een klein aantal basistypen, bijvoorbeeld int voor gehele getallen, double voor reële getallen en boolean voor een logische waarde (true of false).
Daarnaast zijn er in Java ook voorgedefinieerde typen, bijvoorbeeld String, die klassen worden genoemd. Een Java-programmeur kan zelf ook nog nieuwe typen / klassen definiëren.

Voorbeelden van declaraties zijn:
String naam;
int cijfer;
double bedrag;
boolean ok;

Nadat een variabele is gedeclareerd, er is dus aangegeven van welk type en wat de naam van de variabele is, kan er ook een beginwaarde aan een variabele worden toegekend. We noemen dat het initialiseren van een variabele. De initialisatie kan gelijktijdig met het declareren van een variabele plaatsvinden of op een later moment ergens in de programmacode.

Voorbeelden van initialisaties zijn:
String naam = “Jansen”;
int cijfer = 5;
double bedrag = 12.35;
boolean ok = true;

★ Aan de slag 14

Bekijk de volgende programmacode:
String naam;
naam = invoerVeld.getText();
uitvoerVeld.setText(naam);
invoerVeld.setText(“”);

  1. Schrijf de regel waarin de toekenning staat op.
  2. Wat is in die regel de variabelenaam en wat is de expressie?
  3. Schrijf de regel op waarin een declaratie staat.
  4. Van welk type is de variabele in deze regel?
  5. Wat is de betekenis van (“”) in de laatste regel?

 

★ Aan de slag 15

Je bent enkele voorbeelden van typen tegengekomen. Van welk type zijn de volgende waarden?

  1. “Hoofdstraat 54”
  2. 538,908
  3. 5388756
  4. 22

★ Aan de slag 16

In de interactieve module staat ”Je mag niet alle woorden gebruiken als naam voor een variabele.”
Mag je het woord “int” gebruiken als naam voor een variabele? Leg je antwoord uit.

★ Aan de slag 17

Hieronder staat een deel van een Java-programma.
In dit programma komen variabelen en toekenningen voor.

naw = “Alan Turing”+”\n”+”1011 ENIGMA-way”+”\n”+”Silicon Valley”;
int teller;
teller = 1;
naw = nawVeld.getText();
nawGebied.setText(naw);
int a;
int b;
a = 17;
b = 3;
goedeAntwoordVeld.setText(“a + b = 20”);
a = b;
teller = b;
 

Noteer de variabelen en de toekenningen.

 

RenteApplet

Wanneer je geld op een spaarrekening zet, dan krijg je daar rente over. Het kapitaal op de spaarrekening groeit. Om uit te rekenen hoe groot dat kapitaal na een aantal jaar geworden is, kun je een algoritme bedenken en een programma schrijven. De gebruiker van je programma moet eerst een aantal gegevens invoeren: het beginkapitaal, het aantal termijnen en de rente (in procenten). Voor het gemak kun je ervan uitgaan dat de jaarrente een geheel getal is. Wanneer er een termijn verstreken is, moet bij het kapitaal de rente opgeteld worden. Bij de volgende termijn berekent het programma natuurlijk de rente over het nieuwe kapitaal. Dat gaat door tot de laatste termijn is verstreken en dan ziet de gebruiker het kapitaal op het scherm verschijnen.

Het Java-applet heeft drie invoervelden die je heldere namen als beginkapitaalVeld, renteVeld en termijnenVeld geeft.
Je moet ook een uitvoerveld maken, bijvoorbeeld eindkapitaalVeld, en een berekenKnop opnemen.

 

Voor de berekenKnop moet je een event-handler schrijven. De code hiervoor is:

int beginkapitaal;
beginkapitaal = Integer.parseInt(beginkapitaalVeld.getText());
int rente;
rente = Integer.parseInt(renteVeld.getText());
int termijnen;
termijnen = Integer.parseInt(termijnenVeld.getText());
int kapitaal;
kapitaal = beginkapitaal;
int termijn;
termijn = 1;
while (termijn <= termijnen){
  kapitaal = kapitaal + kapitaal * rente / 100;
  termijn = termijn + 1;
}
eindkapitaalVeld.setText(String.valueOf(kapitaal));

★ Aan de slag 18

In deze opdracht gaan we stap voor stap het RenteApplet maken:

  1. Ontwerp de user interface van het RenteApplet. In JavaEditor kan gekozen worden voor een TextField of een NumberField. Gebruik voor het applet tekstvelden. We leggen later uit waarom we dit doen.
  2. Voer de event-handler in.
  3. Sla het applet op.
  4. Test het applet

Operaties - operanden

Toekenning door operaties op operanden
Kijk eens naar de toekenning (ook wel assignment):

kapitaal = kapitaal + kapitaal * rente/100;

Aan de rechterkant staat een expressie waarin verschillende operaties voorkomen. Hier zijn dat: optellen, vermenigvuldigen en delen.
Operaties werken op operanden. In dit geval zijn dat de constante 100 en de variabelen kapitaal en rente

Bij de toekenning aan de variabele kapitaal wordt eerst de expressie aan de rechterkant uitgerekend. Daarbij maakt het programma gebruik van de “oude” waarde van kapitaal. Het resultaat van de berekening wordt daarna toegekend aan de variabele kapitaal. Daarmee gaat de “oude” waarde van kapitaal verloren.

 
 

Herhaling met while

De toekenning kapitaal = kapitaal + kapitaal * rente/ 100; staat in een herhalingslus:

while(termijn <= termijnen){
  kapitaal = kapitaal + kapitaal * rente/100;
  termijn = termijn + 1;
}

Het woord while (zolang) geeft het begin van de lus aan. Een while-opdracht heeft altijd de volgende vorm:

while(voorwaarde){opdracht of opdrachten}

De voorwaarde tussen de ronde haken is een expressie, hier:

(termijn <= termijnen)

Het resultaat daarvan moet een waarde zijn van het type boolean. Dit type kan maar twee waarden aannemen: true (waar) of false (niet waar). Een expressie van dit type wordt ook wel een logische expressie genoemd. Als het resultaat van de voorwaarde true is, dan worden de opdrachten tussen de accolades uitgevoerd en wordt de lus nogmaals verwerkt. Als het resultaat false is, dan worden de opdrachten tussen de accolades overgeslagen en wordt de lus beëindigd.

In het RenteApplet geldt dat het ofwel waar is dat termijn kleiner is dan of gelijk aan termijnen ofwel dat het niet waar is. Als het waar is, dan wordt het kapitaal met de rente verhoogd. Als het niet waar is, dan wordt de lus beëindigd.

★ Aan de slag 19

Bekijk de event-handler van de berekenKnop van het RenteApplet:

int beginkapitaal;
beginkapitaal = Integer.parseInt(beginkapitaalVeld.getText());
int rente;
rente = Integer.parseInt(renteVeld.getText());
int termijnen;
termijnen = Integer.parseInt(termijnenVeld.getText());
int kapitaal;
kapitaal = beginkapitaal;
int termijn;
termijn = 1;
while (termijn <= termijnen){
  kapitaal = kapitaal + kapitaal * rente / 100;
  termijn = termijn + 1;
}
eindkapitaalVeld.setText(String.valueOf(kapitaal));

  1. Welke operaties staan er in deze programmacode?
  2. Op welke operanden werken de operaties in deze programmacode?
  3. Waar begint de herhalingslus?
  4. Van welk type is de voorwaarde in een while-opdracht?
  5. Hoe heet een expressie van dit type?

Methode-aanroep

Een methode-aanroep heeft altijd de volgende vorm:

methode(argumenten)

Een methode kan nul, één of meerdere argumenten hebben. Methoden horen bij een object of soms bij een klasse. Zo moet je beginkapitaalVeld.getText() lezen als “de methode getText() haalt een String uit het object beginkapitaalVeld”. Integer.parseInt() moet je lezen als “de methode parseInt() van de klasse Integer”

Er zijn ook methoden die geen resultaat opleveren en dus niet in een expressie kunnen voorkomen. Een aanroep van zo’n methode kan wel als statement in een programma worden opgenomen.

Een voorbeeld van een dergelijke methode is setText() in de laatste regel: eindkapitaalVeld.setText(String.valueOf(kapitaal));

Samenvattend:

  • De methode getText() heeft als resultaattype een String en heeft geen argumenten:
    String getText()
  • De methode parseInt() heeft als resultaattype een int en heeft als argument een String:
    int parseInt(String)
  • De methode setText() heeft geen resultaattype en heeft als argument een String:
    void setText(String)

Voor de naam van de methode setText() staat als resultaattype het woord void. Het Engelse woord void betekent leeg. Dat wil zeggen dat deze methode geen resultaat heeft. Het is een methode die wel effect heeft, namelijk het plaatsen van een String in een veld.

Conversie deel 1

In de tweede regel van de programmacode van het RenteApplet staat de volgende toekenning:

beginkapitaal = Integer.parseInt(beginkapitaalVeld.getText());

Er staan twee methode-aanroepen in:

  • Integer.parseInt()
  • beginkapitaalVeld.getText()

Beide methoden zullen we bekijken.

De methode getText() haalt een waarde van het type String uit het beginkapitaalVeld.

Deze waarde wordt vervolgens toegekend aan beginkapitaal. Voor het ontwerp van de interface van het RenteApplet in JavaEditor hebben we gevraagd gebruik te maken van een TextField in plaats van een NumberField. We zullen nu toelichten waarom we dat speciale verzoek hebben gedaan. De waarde die uit een tekstveld wordt gehaald, is altijd van het type String. De variabele beginkapitaal is echter van het type int (geheel getal). Een waarde van het type String kan niet zomaar worden toegekend aan het type int. In het RenteApplet gaan we rekenen met getallen. We moeten de waarde die we uit het tekstveld halen daarom omzetten naar een getal. Om een waarde van het type String om te zetten naar het type int gebruik je de methode parseInt() uit de klasse Integer.

Het omzetten van een waarde van het ene type in een waarde van een ander type noemen we conversie. Daarvoor worden verschillende methoden gebruikt:

  • parseInt() uit de klasse Integer: om een waarde van het type String te converteren naar het type int.
  • parseDouble uit de klasse Double: om een waarde van het type String te converteren naar het type double.
  • valueOf() uit de klasse String: om een waarde van het type int of double te converteren naar het type String.

Na het uitrekenen van het eindbedrag willen we het totaalbedrag laten zien in het eindkapitaalVeld. Een tekstveld accepteert echter alleen waarden van het type String. Er is dus wederom conversie vereist. Het geheel getal moet worden omgezet naar een waarde van het type String. We gebruiken daarvoor de methode valueOf() uit de klasse String.

Na de conversie van int naar String plaatsen we met de methode setText() de waarde van de variabele eindkapitaal in het eindkapitaalVeld

eindkapitaalVeld.setText(String.valueOf(kapitaal));

Als we in de interface van het RenteApplet in plaats van TextField’s NumberField’s hadden gebruikt, hadden we geen conversieregels hoeven toe te passen.
In plaats van beginkapitaal = Integer.parseInt(beginkapitaalVeld.getText());
had er dan gestaan beginkapitaal = beginkapitaalVeld.getInt();.
De methode getInt() haalt een waarde van het type int uit het beginkapitaalVeld. Het beginkapitaalVeld moet dan wel een numeriek veld zijn. De code voor de event-handler van de berekenKnop had er ook een stuk eenvoudiger uit gezien. Deze code staat op de volgende pagina.

int beginkapitaal;
beginkapitaal = beginkapitaalVeld.getInt();
int rente;
rente = renteVeld.getInt();
int termijnen;
termijnen = termijnenVeld.getInt();
int kapitaal;
kapitaal = beginkapitaal;
int termijn;
termijn = 1;
while (termijn <= termijnen){
  kapitaal = kapitaal + kapitaal * rente / 100;
  termijn = termijn + 1;
}
eindkapitaalVeld.setInt(kapitaal);

Als je goed met Java wilt werken, is het erg belangrijk dat je je bewust bent van het werken met verschillende typen variabelen. Dat is de reden waarom we in dit voorbeeld gekozen hebben voor TextField’s in plaats van NumberField’s. In vervolgopdrachten mag je gebruik maken van NumberField’s als er gewerkt wordt met getallen.

★ Aan de slag 20

Bekijk de volgende programmacode:

String looninvoer;
looninvoer = loonVeld.getText();
int loon;
loon = Integer.parseInt(looninvoer);

  1. Welke twee methoden staan er in de code?
  2. Van welk type is het resultaat in de eerste methode-aanroep?
  3. Van welk type is het resultaat in de tweede methode-aanroep?
  4. Van welk type is het argument in de tweede methode-aanroep?

 

★ Aan de slag 21

Bekijk de volgende programmacode:

uitvoerVeld.setText(String.valueOf(loon * 1.05));

  1. Welke twee methoden staan er in de code?
  2. Welke methode is een void-methode?
  3. Wat betekent het dat een methode een void-methode is?
  4. Welke methode gebruik je om een getal om te zetten in een tekst?

Statements

Opdrachten worden ook wel statements genoemd.
Voorbeelden van elementaire statements zijn:

  • de declaratie int beginkapitaal;
  • de toekenning termijn = termijn + 1;

Ook de while-opdracht is een statement, maar dan wel een samengesteld statement. Elementaire statements worden altijd afgesloten met een puntkomma, maar een samengesteld statement niet.

while(termijn <= termijnen)
{
kapitaal = kapitaal + kapitaal * rente/100;
termijn = termijn + 1;
}

 

★ Aan de slag 22

In de interactieve module lees je wat statements zijn.

    1. Geef een voorbeeld van een elementair statement.
    2. Geef een voorbeeld van een samengesteld statement.
       
    1. Zet in de regel kapitaal = kapitaal + kapitaal * rente / 100;
      kapitaal + kapitaal tussen haakjes.
      Wat gaat er fout?
    2. Zet vervolgens rente / 100 tussen haakjes.
      Kun je verklaren wat er gebeurt?

★ Aan de slag 23

In de interactieve module hebben we als voorbeeld van een programma het RenteApplet bekeken.
Voor het gemak zijn we daar van gehele getallen uitgegaan.
Wil het programma in de praktijk bruikbaar zijn, dan zal het met reële getallen moeten werken.
Herschrijf het RenteApplet zodat het met reële getallen werkt.
Je mag bij deze opdracht gebruik maken van numerieke velden en de methoden getDouble() en setDouble().

 

Open in JavaEditor het RenteApplet waarin je gebruik hebt gemaakt van numerieke velden.
Compileer de code en voer het programma uit.
Voer nu in het beginkapitaalVeld de waarde 100,00 in.
Wat gebeurt er?
Kun je daar een verklaring voor geven?

 

 

 

★ Aan de slag 24

  1. Schrijf een programma dat een bedrag in euro’s omzet naar dollars.
    De wisselkoers is 1 euro is 1,118 dollar.
  2. Breid het programma uit met een extra knop zodat dollars omgerekend kunnen worden naar euro’s.

★ Aan de slag 25

Maak een RekenmachineApplet zoals in het voorbeeld hiernaast.
In de bovenste twee velden worden twee getallen ingevoerd.
De plustoets geeft als resultaat de som, de mintoets het verschil, de maaltoets het product en de deeltoets het quotiënt.
Het resultaat wordt in het onderste veld geplaatst.
Alleen bij de deeltoets moet je rekening houden met decimale getallen.

★ Aan de slag 26

Maak een applet dat strafwerkregels kan maken.
De gebruiker typt de gevraagde strafwerkregel in.
Daarna geeft hij op hoe vaak de regel moet worden afgebeeld en vervolgens wordt door een druk op de knop het strafwerk gemaakt.
Voor de uitvoer wordt gebruik gemaakt van een object uit de klasse TextArea.

Kijk nog eens naar opgave “Aan de slag 9”.
Daar vind je hoe je een TextArea kunt gebruiken.

 

 

★ Aan de slag 27

Peter wil voor zijn leerlingen een applet maken die een bepaalde tafel op het scherm toont.
De invoer van het tafelgetal gebeurt in een TextField.
De uitvoer in een TextArea.
Door op de knop Toon Tafel te klikken verschijnt de tafel in het uitvoerGebied.

N.B.
Met het plusteken kunnen twee of meer Strings aan elkaar gekoppeld worden, bijvoorbeeld: String.valueOf(getal) + ”tekst”

★ Aan de slag 28

In opgave “Aan de slag 26 b” heb je een applet geschreven dat euro’s naar dollars omrekent en omgekeerd.
Het applet rond de bedragen niet af op twee cijfers achter de komma (decimale punt).
Pas het applet aan zodat bedragen met maximaal twee cijfers achter de komma worden weergegeven.

★ Aan de slag 29

Jane heeft een krantenwijk.
Dit levert haar iedere week € 60,00 op.
Ze besluit te sparen voor een smartphone. Ze heeft een mooie smartphone gezien voor € 570, een andere kost € 450. Jane wil weten hoe lang ze moet sparen als ze bijvoorbeeld iedere week de helft van haar verdiende geld spaart. Maar het zou ook kunnen zijn dat ze er voor kiest om bijvoorbeeld maar 40% te sparen.

Maak een applet, waarbij Jane haar weeksalaris, het deel van het salaris dat ze wil sparen en het bedrag dat ze wil sparen, kan invoeren. De uitvoer is het aantal weken dat ze moet sparen.

Let op! Het salaris, het percentage en het gewenst spaarbedrag zijn gehele getallen, het aantal weken niet.

★ Aan de slag 30

In 1202 vroeg de Leonardo van Pisa (ook wel Fibonacci genoemd) zich af hoe snel konijnen zich in ideale omstandigheden voortplanten. Hij stelde zichzelf de vraag: hoeveel konijnenparen zullen er na een jaar zijn, wanneer er een pasgeboren stel konijnen, een mannetje en een vrouwtje, wordt losgelaten op een terrein. Daarbij ging hij uit van de volgende voorwaarden:

  • elk baby-konijnenpaar is na één maand volwassen en vruchtbaar;
  • elk volwassen konijnenpaar brengt na elke maand één baby-konijnenpaar (een mannetje en een vrouwtje) voort;
  • er sterft geen enkel konijn.

Uitgesplitst naar babyparen en volwassen paren:

Maand: 1 2 3 4 5
Aantal babyparen: 1 0 1 1 2
Aantal volwassenparen: 0 1 1 2 3


In de eerste maand is er één baby-konijnenpaar, de tweede maand is dat paar volwassen geworden en de derde maand komt er een baby-konijnenpaartje bij etc.

  1. Maak het onderstaand schema af:
Maand: 1 2 3 4 5 6 7 8 9
Aantal babyparen: 1 0 1 1 2 3      
Aantal volwassenparen: 0 1 1 2 3 5      
Totaal aantal paren: 1 1 2 3 5        

 

  1. ​Hoe bepaal je het totaal aantal paren in maand 8?
  2. Hoe bepaal je het totaal aantal paren in maand n?
  3. Schrijf een applet dat het aantal konijnenparen geeft dat op een willekeurige maand n in het veld rondloopt.


D Herhaling en keuze

Inleiding

Je hebt in de vorige onderdelen al kennis gemaakt met een herhalingslus. In deze paragraaf leer je andere voorbeelden van herhalingslussen kennen. Bij een herhaling moet Java vaak waarden met elkaar kunnen vergelijken. Java kent daarvoor een aantal relationele operatoren:

operator betekenis
< kleiner dan
> groter dan
<= kleiner dan of gelijk aan
>= groter dan of gelijk aan
== is gelijk aan
!= is ongelijk aan


 

★ Aan de slag 31

Java maakt gebruik van relationele operatoren.
Leg in eigen woorden uit wat relationele operatoren zijn.

RenteApplet 2

Het RenteApplet anders geschreven
In het vorige onderdeel heb je de code van het RenteApplet bekeken. In de eerste uitwerking van het RenteApplet hebben we gewerkt met tekstvelden. Later hebben we de tekstvelden vervangen door numerieke velden en de programmeercode aangepast.

In een programmeertaal als Java kun je dezelfde dingen op verschillende manieren opschrijven. Hieronder staat het RenteApplet op een andere manier geschreven. Er is een aantal verschillen. We laten de verschillen tussen het gebruik van tekstvelden en numerieke velden even buiten beschouwing.

double beginkapitaal = beginkapitaalVeld.getDouble();
double rente = renteVeld.getDouble();
int termijnen = termijnenVeld.getInt();
double kapitaal = beginkapitaal;
for (int termijn = 1; termijn <= termijnen; termijn++) {
  kapitaal = kapitaal + kapitaal * rente / 100;
}
eindkapitaalVeld.setDouble(kapitaal);

Declaratie en toekenning

In de eerste regel is sprake van een declaratie én een toekenning in één statement:

double beginkapitaal = beginkapitaalVeld.getDouble();

Java biedt de mogelijkheid een variabele te initialiseren (een beginwaarde te geven) bij de declaratie. Dit wordt beschouwd als een goede programmeerstijl. Variabelen die niet geïnitialiseerd zijn, waaraan dus geen beginwaarde is toegekend, zijn vaak een bron van fouten.

Decimaal > binair

In de interactieve module elementaire bewerkingen hebben we laten zien hoe decimale getallen omgezet kunnen worden naar binaire getallen. Het algoritme daarvoor is:
“Om een decimaal getal om te zetten in een binair getal deel je het getal door 2 en noteer je de rest van de deling. Dit herhaal je totdat de uitkomst is gelijk aan 0”.

Je zou in Java een applet kunnen maken dat een decimaal getal omzet in een binair getal. Voor de knop die de omzetting doet, moet een event-handler worden geschreven.
De code daarvoor is:
public void berekenKnop_ActionPerformed(ActionEvent evt) {
  int decGetal = decimaalVeld.getInt();
  String resultaat = "";
  do {
     resultaat = String.valueOf(decGetal % 2) + resultaat;
     decGetal = decGetal / 2;
  } while (decGetal > 0);
  binairVeld.setInt(Integer.parseInt(resultaat));
}

★ Aan de slag 32

  1. Ontwerp de interface van het DecBinApplet.
  2. Voer de event-handler in.
  3. Zet de decimale getallen 87, 153 en 231 met het DecBinApplet om in binaire getallen.
  4. Waarom moet het statement String resultaat = “”; in het programma staan?
  5. Wat doet de operator %?

Toets 1

In de volgende toets wordt getoetst wat je inmiddels zou moeten weten over het onderwerp programmeren in Java.
Klik op de link en maak de toets.

Herhaling en keuze

Het for-statement

In het RenteApplet is de herhalingsconstructie while vervangen door het for-statement:

for(int termijn = 1; termijn <= termijnen; termijn++) {
  kapitaal = kapitaal + kapitaal * rente / 100;
}

Een for-statement heeft altijd de volgende vorm:

for(initialisatieopdracht; voorwaarde; stapopdracht) {
  opdracht(en);
}

Het is eigenlijk alleen maar een verkorte schrijfwijze van

initialisatieopdracht;
while(voorwaarde) {
  opdracht(en);
  stapopdracht;
}

Het deel tussen de ronde haakjes heeft drie onderdelen:

  1. Het eerste onderdeel is een initialisatie. Deze wordt meestal gebruikt om een variabele, die wel de stuurvariabele van het for-statement genoemd wordt, een beginwaarde te geven.
  2. Het tweede onderdeel is een logische expressie. Zolang het resultaat true , worden de opdrachten tussen de accolades uitgevoerd.
  3. Het derde onderdeel is een stapopdracht, meestal een opdracht die de stuurvariabele wijzigt. Het statement termijn++ verhoogt termijn met 1 (het resultaat is hetzelfde als van de expressie termijn = termijn + 1)

 

★ Aan de slag 33

We hebben de event-handler van de berekenKnop van het RenteApplet naderhand anders geschreven.

  1. Noem de twee belangrijkste verschillen
  2. Wat is het voordeel van een declaratie en een toekenning in één regel.

Het do-while-statement

Een do-while-statement heeft altijd de volgende vorm:

do{opdracht(en)} while(voorwaarde);

Deze herhalingsopdracht is nauw verwant aan het while-statement, maar kent twee belangrijke verschillen:

  1. De opdrachten tussen de accolades worden minstens één keer uitgevoerd.
  2. Het berekenen van de voorwaarde vindt aan het eind plaats.

Eerst worden de opdrachten tussen de accolades verwerkt. Daarna wordt de logische expressie achter de while beoordeeld. Als het resultaat true is, worden de opdrachten tussen de accolades opnieuw verwerkt. Is het resultaat false, dan wordt de do-while-opdracht beëindigd.

 

★ Aan de slag 34

In de DecBinApplet wordt gebruik gemaakt van het do-while-statement.
Het do-while-statement is nauw verwant aan het while-statement.
Noem twee belangrijke verschillen

Het if-else-statement

Het OverwerkApplet berekent welk bedrag aan een werknemer betaald moet worden als vergoeding voor overwerk. Tevens geeft het applet aan wanneer er niet overgewerkt is. De gebruiker van het applet voert een viertal gegevens in: het uurloon, het aantal uren dat de werknemer normaal werkt, het vergoedingspercentage voor overwerk en het aantal uren dat de werknemer werkelijk gewerkt heeft.
Voor de berekenKnop moet je een eventhandler schrijven. De code hiervoor is:

int uurloon = uurloonVeld.getInt();
int taakomvang = taakomvangVeld.getInt();
int vergperc = vergPercVeld.getInt();
int gewerkt = gewerktVeld.getInt();
if (gewerkt > taakomvang){
int loon = (gewerkt - taakomvang) * uurloon * vergperc / 100;
   resultaatLabel.setText("Vergoeding overwerk: " + String.valueOf(loon));
}
else {
   resultaatLabel.setText("Niet overgewerkt!");
}

Tijdens de verwerking van het OverwerkApplet wordt een keuze gemaakt: is er wel of niet overgewerkt. Dit gebeurt met een if-else-statement. Net als het while-statement is dit een samengesteld statement.
Een if-else-statement heeft de volgende vorm:

if(logische expressie) opdrachtl else opdracht2

Bij de uitvoering wordt eerst de logische expressie berekend. Is het resultaat true, dan wordt opdracht1 verwerkt. Wanneer het resultaat false is, wordt opdracht2 verwerkt. In het geval dat opdracht1 of opdracht2 uit meer dan één statement bestaat, komen de statements tussen accolades.

Een variatie is het if-statement:

if(logische expressie) opdracht

Wanneer het resultaat van de logische expressie true is, wordt de opdracht uitgevoerd. Is het resultaat false, dan wordt de opdracht overgeslagen.

★ Aan de slag 35

  1. Ontwerp de interface van het OverwerkApplet.
  2. Voer de event-handler in.
  3. In het applet staat de expressie:
    int loon = (gewerkt - taakomvang) * uurloon * vergperc / 100;
    Stel dat je in plaats van deze expressie de volgende code hebt getypt:
    int loon = (gewerkt - taakomvang) * uurloon * (vergperc / 100);
    Wat gaat er mis?

 

★ Aan de slag 36

In het OverwerkApplet wordt gebruik gemaakt van het if-else-statement.

    1. Wat is de algemene vorm van het if-else-statement?
    2. Het if-else-statement is nauw verwant aan het if-statement. Wat is het verschil tussen deze twee statements?
       
  2. Variabelen die niet zijn geïnitialiseerd, zijn vaak een bron van fouten.
    Leg uit waarom.

★ Aan de slag 37

  1. Wat zal er met een programma gebeuren als de volgende lus wordt uitgevoerd:

    do {
      kapitaal = kapitaal * rente/100;
      termijn = 4;
    } while(termijn <=10);

     

    Leg je antwoord uit.

  2. Wat zal er met een programma gebeuren als de volgende lus wordt uitgevoerd:

    while(termijn <=termijnen);
    {
      kapitaal = kapitaal * rente/100;
      termijn = termijn + 1;
    }

     

    Leg je antwoord uit.

★ Aan de slag 38

Een jaar is een schrikkeljaar als het jaartal deelbaar is door 4.
Daar is echter een uitzondering op: als het jaar deelbaar is door 100 dan is het geen schrikkeljaar.
Ook op die regel is weer een uitzondering: als het jaartal deelbaar is door 400 is het wel weer een schrikkeljaar.

Maak een applet dat bepaalt of een jaar een schrikkeljaar is.

★ Aan de slag 39

In deze opdracht moet je een applet schrijven dat een Syracuserij maakt van een getal. Een Syracuserij is een rij getallen die begint met een positief, geheel getal. Het volgende getal in de rij krijg je door het getal door twee te delen, als het getal even is. Is het een oneven getal, dan wordt het getal met 3 vermenigvuldigd en vervolgens wordt bij het resultaat 1 opgeteld.

In de afbeelding zie je de Syracuserij van het getal 7.
Bij 1 stopt de rij omdat daarna steeds de reeks 4 2 1 herhaald wordt.

 

Het switch-statement

Het switch-statement wordt gebruikt wanneer je een groot aantal if-statements achter elkaar moet schrijven. Stel dat de dag van de week is opgeslagen in een variabele dag van het type int met een van de waarden 1 tot en met 7 voor de dagen maandag tot en met zondag:

if(dag == 1)
     dagLabel.setText(“maandag”);
else if(dag == 2)
     dagLabel.setText(“dinsdag”);
else if(dag == 3)
     dagLabel.setText(“woensdag”);
else if(dag == 4)
     dagLabel.setText(“donderdag”);
else if(dag == 5)
     dagLabel.setText(“vrijdag”);
else if(dag == 6)
     dagLabel.setText(“zaterdag”);
else if(dag == 7)
     dagLabel.setText(“zondag”);
else
     dagLabel.setText(“Geen geldig dagnummer”);

Je krijgt een groot aantal keer else onder elkaar en de code is minder overzichtelijk.
Met het switch-statement wordt de structuur van de code duidelijker:

switch(dag) {
    case 1: dagLabel.setText(“maandag”); break;
    case 2: dagLabel.setText(“dinsdag”); break;
    case 3: dagLabel.setText(“woensdag”); break;
    case 4: dagLabel.setText(“donderdag”); break;
    case 5: dagLabel.setText(“vrijdag”); break;
    case 6: dagLabel.setText(“zaterdag”); break;
    case 7: dagLabel.setText(“zondag”); break;
    default: dagLabel.setText(“Geen geldig dagnummer”);
}

Een switch-statement begint altijd met het woord switch.
Daarachter staat tussen haakjes de switch-expressie, in dit geval de variabele dag. In principe moet de variabele van het type int of char zijn. De waarde van dag wordt vergeleken met de constanten die achter case staan. Hij moet van hetzelfde type zijn als de switch-expressie. Als die waarde gelijk is worden alle statements achter de dubbele punt na case uitgevoerd. Het woord break betekent: beëindig de uitvoering van het switch-statement. Als de waarde van dag niet gelijk is aan een van de constanten achter case, worden de statements achter default uitgevoerd. Overigens is het niet verplicht om de default-label te gebruiken.

★ Aan de slag 40

Bij hockey zijn er de onderstaande categorieën per leeftijd:

F1 6 jaar
F2 7 jaar
E1 8 jaar
E2 9 jaar
D8 10 jaar
D 11 jaar
C 12 en 13 jaar
B 14 en 15 jaar
A 16 en 17 jaar
Senioren 18 jaar en ouder

Schrijf een applet dat de juiste categorie toont als een willekeurige leeftijd wordt ingevoerd. Ook moet er een melding verschijnen als de leeftijd jonger is dan 6.

E Variabelen-operatoren

Inleiding

In deze module heb je al eerder kennis gemaakt met het gebruik van variabelen in een Java-programma. Je kunt een variabele voorstellen als een doos met aan de buitenkant een sticker waar de naam op staat. In de doos zit een waarde (bijvoorbeeld een getal). De waarde kan door het programma gewijzigd worden, maar de naam niet. Een variabele heeft een type. Het type bepaalt welke waarden de variabele kan aannemen en welke operaties er op kunnen worden uitgevoerd. Het type is a.h.w. de vorm van de doos.

Java kent twee soorten variabelen:

  1. Variabelen die naar een object verwijzen. Dergelijke variabelen worden referenties genoemd. De doos bevat dus niet het object zelf, maar een verwijzing (zeg maar het adres) van de plek in het geheugen waar het object zich bevindt. De klasse Button, TextField en Label zijn voorbeelden van referentietypen.
  2. Daarnaast kent Java 8 primitieve typen: byte, short, int, long, float, double, char en boolean. Variabelen van dat type verwijzen niet naar een object. De doos bevat de waarde zelf.

In dit onderdeel wordt een aantal primitieve typen behandeld. In het volgend onderdeel wordt de klasse String als voorbeeld van een referentietype bekeken.

Gehele getallen

Het type int representeert gehele getallen.
Er wordt 32 bits gereserveerd om een waarde van dit type op te slaan.
Een getal van het type int moet daarom liggen tussen – 2147483648 en + 2147483647 (tussen -231 en +231-1).

Behalve het type int kent Java ook nog de typen byte, short en long voor gehele getallen.
Het bereik van deze typen verschilt: byte 8 bits, short 16 bits en long 64 bits.

★ Aan de slag 41

  1. Hoe maak je een variabele getal van het type int aan?
  2. Hoe ken je een getal 5 toe aan de variabele getal?

Reële getallen

Voor het opslaan van reële getallen kent Java het type double. Een reëel getal noteer je in Java met een decimale punt. Een waarde van het type double wordt opgeslagen in 64 bits. Daarnaast is er ook nog het type float. Deze waarden worden in 32 bits opgeslagen. Het type double kan grotere getallen representeren en is ook nauwkeuriger. De interne representatie van waarden van het type float of double lijkt op de representatie van getallen in “wetenschappelijke notatie” (zoals 3.452510562E-03) die je op veel calculators aantreft.

Operatoren

Java kent de volgende rekenkundige operatoren:

Operator Betekenis
+ optellen
- aftrekken
* vermenigvuldigen
/ delen
% rest van een deling

 

De operator / geeft bij een deling van waarden van het type int als resultaat een geheel getal: 15/2 geeft als resultaat 7 en niet 7.5. Bij een deling van waarden van het type double is het resultaat een reëel getal: 15.0/2 geeft als resultaat 7.5. De operator % levert de rest van een deling: 15%2 geeft als resultaat 1.

★ Aan de slag 42

Geef het resultaat van x / y en x % y bij de volgende waarden voor x en y:

  1. x = 7 en y = 3
  2. x = 3.5 en y = 2
  3. x = 5 en y = 0

Random getallen

Het maken van random getallen (toevalsgetallen) komt veel voor in allerlei programma’s. In Java maak je een random getal met behulp van de methode random() uit de klasse Math. We nemen als voorbeeld een applet die het werpen van een dobbelsteen simuleert. In de event-handler van de dobbelKnop komt de volgende code te staan:

double randomGetal = Math.random();
int worp = (int)(6*randomGetal) + 1;
dobbelsteenVeld.setInt(worp);

In de eerste regel staat de methode random() uit de klasse Math. Met deze methode kun je willekeurige getallen laten berekenen. Elke keer als je de methode random() aanroept, levert dat een willekeurig reëel getal van 0.0 tot 1.0 op (1.0 komt zelf niet voor).
In de tweede regel staat een expressie waarvan het resultaat een getal is uit de verzameling {1, 2, 3, 4, 5, 6}.
Het resultaat van de expressie is van het type double. De variabele worp, waarin het resultaat wordt opgeslagen, is van het type int. Je kunt je afvragen of dat zomaar kan.

★ Aan de slag 43

  1. Ontwerp de interface van het DobbelApplet.
  2. Voer de event-handler van de dobbelKnop in.

Numerieke variabelen

Conversie van numerieke variabelen
In het onderstaande voorbeeld levert de conversie geen probleem op:

int x, y ;
x = 10 ;
y = 20 ;
double resultaat ;
resultaat = x + y ;

In het statement resultaat = x + y; komen twee verschillende typen voor, maar Java kan die zonder problemen converteren. De int-waarde van het resultaat wordt geconverteerd naar double. Dit wordt een impliciete conversie genoemd.

Het volgende voorbeeld geeft wel een probleem:

double x, y;
x = 1,5;
y = 2,7;
int uitkomst;
uitkomst = x + y;

In het voorbeeld wordt geprobeerd een getal van het type double te converteren naar int: uitkomst = x + y; Dit staat Java niet zonder meer toe, want er kan dan informatie verloren gaan. Wanneer hier toch een conversie gewenst is, kan dat met behulp van een expliciete conversie. Dit wordt casting genoemd (“in een bepaalde vorm gieten”). Om een expressie naar een bepaald type te converteren schrijven we de typenaam tussen haakjes voor de expressie:

(typenaam)expressie

Door het woord int tussen haakjes voor de expressie te zetten, geef je Java de opdracht om x + y te converteren naar int.

★ Aan de slag 44

  1. In het eerste voorbeeld is er sprake van een conversie van int naar double.
    Waarom zou Java deze conversie zonder problemen uitvoeren?
     
  2. In het tweede voorbeeld is er sprake van een conversie van double naar int.
    De compiler geeft hier een foutmelding.
    Wat zou de reden van de foutmelding zijn?

★ Aan de slag 45

In de programmacode moet het statement als volgt worden aangepast :

uitkomst = (int) (x + y);

  1. Waarom moet voor de expressie (int) staan?
  2. Waarom staat (x + y) tussen haakjes?

★ Aan de slag 46

Wat is het verschil tussen een impliciete en een expliciete conversie?

★ Aan de slag 47

In het voorbeeld van de dobbelsteen geeft de code
int worp = 6 * randomGetal + 1; hetzelfde conversieprobleem. Omdat in dit geval een conversie gewenst is, converteren we het getal van het type double naar int:

int worp = (int) (6 * randomGetal) + 1;

We komen nog even terug op de deling uit het onderdeel over operatoren. Bekijk het volgende voorbeeld:

double resultaat = 15 / 2 ;

Het resultaat van deze deling wordt opgeslagen in een variabele van het type double. Je zou verwachten dat in resultaat de waarde 7.5 wordt opgeslagen. Dat is niet het geval. De uitkomst is 7. De verklaring is dat hier twee gehele getallen op elkaar gedeeld worden. Er is hier sprake van een gehele deling waarvan de uitkomst 7 is. Deze uitkomst wordt opgeslagen in de variabele resultaat middels een impliciete conversie: 7.0. Ook in dit geval zal er een expliciete conversie moeten plaatsvinden:

double resultaat = (double) 15 / 2 ;

  1. Pas het DobbelApplet aan, zodat je met twee dobbelstenen gooit en daarbij het totaal aantal ogen telt.
  2. Pas het DobbelApplet aan, zodat het resultaat van een worp een even getal is: {2, 4, 6, 8, 10, 12}.

★ Aan de slag 48

Bekijk de volgende programmacode:

double resultaat;
resultaat = 4.5 + 7 / 2;

  1. Welke andere waarde dan de waarschijnlijk bedoelde 8.0 zal in resultaat worden opgeslagen?
  2. Leg uit hoe dat komt.
  3. Verbeter de code zodat wel het juiste resultaat wordt opgeslagen in resultaat.

 

★ Aan de slag 49

Geef het resultaat van de volgende berekeningen:

  1. int uitkomst = 5 / 4;
  2. double resultaat = 5 / 4;
  3. double resultaat = 5.0 / 4;
  4. double resultaat = (double) 5 / 4;

Type boolean

Het type boolean kan maar twee waarden hebben: true of false. In het volgende deel van een stukje programmacode zie je het gebruik van het type boolean in combinatie met een if-statement:

boolean ok = a > 10;
if (ok)
  tekstLabel.setText(”Je bent klaar”);

Op het type boolean kunnen de logische operatoren &&, ||en ! werken. Het resultaat van een expressie met logische operatoren is van het type boolean. De &&-operator is de logische AND. In de expressie x && y is het resultaat alleen true als zowel x als y true zijn.

x y x && y
false false false
true false false
false true false
true true true

 

De ||-operator is de logische OF. In de expressie x || y is het resultaat true als x of y true is of beiden true zijn.

x y x || y
false false false
true false true
false true true
true true true

 

De !-operator is de logische NOT. In de expressie !x is het resultaat true als x false is en is het resultaat false als x true is.

x !x
true false
false true

Net zoals *, / en % voor numerieke typen (int, float, etc.) een hogere prioriteit hebben dan + en –, heeft ! een hogere prioriteit dan && en die weer een hogere dan ||.

Om waarden met elkaar te kunnen vergelijken kent Java een aantal relationele operatoren:

< kleiner dan
> groter dan
<= kleiner dan of gelijk aan
>= groter dan of gelijk aan
== is gelijk aan
!= is ongelijk aan

 

Een relationele operator vergelijkt het resultaat van twee expressies (van numeriek type) met elkaar, bijvoorbeeld a >= b + c;. Het resultaat is van het type boolean.

 

★ Aan de slag 50

  1. Geef het resultaat van de volgende expressies wanneer x = true en y = false
    1. x > y
    2. x == y
    3. x != y
    4. x > y && x – y == 6
    5. x > y || x – y == 6
       
  2. Geef het resultaat van de volgende expressies wanneer x = 10 en y = 5 
    1. x || y
    2. x && y
    3. x && !y
    4. x > y && x – y == 6
    5. x > y || x – y == 6
       
  3. Wat is het verschil tussen een lokale variabele en een instance variabele?

Variabelen

Lokale variabelen en instance variabelen
We bekijken nog even de event-handler van de dobbelKnop:

public void dobbelKnop_ActionPerformed(ActionEvent evt) {
double randomGetal = Math.random();
int worp = (int)(6*randomGetal) + 1;
dobbelsteenVeld.setInt(worp);
}

In de event-handler worden twee variabelen gedeclareerd: randomGetal en worp. Omdat deze variabelen in de event-handler gedeclareerd worden, kun je ze alleen in de eventhandler gebruiken. In Java geldt dat variabelen die in een body van bijvoorbeeld een methode of van een lus gedeclareerd worden alleen daar gebruikt kunnen worden. We spreken in dit verband over lokale variabelen.

Wanneer je de variabele worp ook in andere methoden wilt gebruiken dan moet je de variabele niet in de event-handler declareren, maar direct aan het begin van de klasse DobbelApplet. Zie de code op de volgende pagina.

public class DobbelApplet extends Applet {
// Begin variabelen
int worp;

In dit voorbeeld kun je de variabele worp in de hele klasse DobbelApplet gebruiken. We spreken dan over een instance variabele.

 

★ Aan de slag 51

Bij een sportwedstrijd wordt er vaak getost met een munt om te bepalen welke ploeg de bal uit mag nemen. De kans dat kop of munt gegooid wordt, is even groot. Tenminste dat nemen wij aan.

Schrijf een applet dat tienduizend keer een munt opgooit. Van iedere worp moet het programma bijhouden of het kop of munt is.

★ Aan de slag 52

De docent wiskunde heeft jou gevraagd een programma te maken, waarmee zijn leerlingen het optellen van twee getallen kunnen oefenen. Hij wil dat het programma een nieuwe som maakt als de leerling op de knop Nieuwe som klikt. De twee getallen, die opgeteld moeten worden, liggen tussen de 0 en de 100.

Gebruik instance variabelen om de twee getallen op te slaan.

★ Aan de slag 53

Op het Enigma-College worden leerlingen van het eerste leerjaar beoordeeld op grond van 7 rapportcijfers. Daarbij worden de volgende regels toegepast:

  • Rapportcijfers zijn gehele getallen van 3 tot en met 10.
  • De cijfers 1 en 2 worden niet gegeven.
  • Een leerling met 1 of meer drieën wordt afgewezen (blijft zitten).
  • Een leerling met 3 of meer vieren wordt afgewezen.
  • Een leerling met 2 vieren en 1 of meer vijven wordt afgewezen.
  • Een leerling met 2 of meer vijven en 1 vier wordt afgewezen.
  • Een leerling met 3 of meer vijven wordt afgewezen.
  • Een leerling met 2 vieren of 1 vier en 1 vijf en met in het totaal 42 punten of meer wordt besproken; is het minder dat 42 dan wordt hij afgewezen.
  • In alle overige gevallen wordt de leerling bevorderd.

Schrijf een applet dat bepaalt of een leerling afgewezen is, besproken moet worden of bevorderd is. De invoer van het programma bestaat uit vier getallen: het aantal drieën, het aantal vieren, het aantal vijven en het puntentotaal. De uitvoer bestaat uit één van de woorden Bevorderen, Bespreken of Afwijzen (conform de regels).

★ Aan de slag 54

Het raadspel is een eenvoudig spelletje waarbij een speler een getal tussen de 1 en de 100 in gedachten moet nemen. De andere speler moet het getal raden. De eerste speler geeft na elke gok aan of het getal dat de tweede speler geraden heeft te hoog, te laag of precies goed is. Schrijf een versie van het raadspel, waarbij de computer een getal tussen de 1 en 100 neemt en de speler het getal moet raden.

Gebruik een instance variabele om het te raden getal op te slaan.

 

★ Aan de slag 55

Schrijf een versie van het raadspel, waarbij de speler een getal tussen de 1 en de 100 in gedachten neemt en de computer het getal moet raden. Bedenk daarbij een goed algoritme voor de computer om het getal te raden.

★ Aan de slag 56

Hiernaast zie je een afbeelding van een eenvoudige rekenmachine. Deze rekenmachine kan van twee reële getallen de som, het verschil, het product en het quotiënt bepalen. Als decimaalteken wordt de punt gebruikt. Een gebruiker voert in door op de toetsen van de rekenmachine te klikken.

Schrijf een versie van de rekenmachine.

★ Aan de slag 57

Charles en Ada gaan regelmatig naar het casino om roulette te spelen. Ze spreken iedere keer af hoeveel geld ze mee zullen nemen. De ene avond is dat € 10, een andere avond kan dat € 100 zijn.
De basisinzet is € 1.

Charles speelt uitsluitend op oneven en Ada uitsluitend op even. Bij winst wordt in dat geval de inzet verdubbeld. Beide spelers hebben een methode bedacht die hun beginkapitaal moet verdubbelen.

Wanneer Charles verliest dan verdubbelt hij zijn inzet. Wanneer hij wint dat gaat hij terug naar de basisinzet.

Ada verhoogt bij verlies de inzet met € 1 en bij winst gaat zij ook terug naar de basisinzet.

De kans dat het balletje op even of op oneven valt is even groot, maar niet helemaal 50%. Op de roulette bevinden zich ook twee vakjes met het opschrift 0 en 00. Wanneer daar het balletje op valt, wint de bank.

Schrijf een applet dat een bezoek van Charles en Ada aan het casino simuleert.
Zorg ervoor dat er verschillende beginkapitalen opgegeven kunnen worden.

F Strings

Inleiding

Voor het werken met Strings (rijen tekens) kent Java de klasse String. Een voorbeeld van een String is “ENIGMA”, maar ook “2021”. Het feit dat een String geen primitief type is, maar een instantie van de klasse String maakt dat het werken met Strings anders is dan het werken met een variabele van bijvoorbeeld het type int.
De oorzaak van dit verschijnsel ligt in het feit dat alle klassen, dus ook String referentietypen zijn. De ==-operator vergelijkt alleen de referenties (verwijzingen naar het geheugenplaatsen), en niet de objecten zelf. Die staan in het geheugen. Om te controleren of twee strings dezelfde inhoud hebben kun je dus niet de operator == gebruiken, maar moet je een methode gebruiken. Je kunt bijvoorbeeld met de methode equals() controleren of twee strings gelijk zijn. Deze methode geeft als resultaat een boolean-waarde:

String naam1 = “Jan”;
String naam2 = “Piet”;
if (naam1.equals(naam2))
  resultaatLabel.setText(“Gelijk”);
else
  resultaatLabel.setText(“Ongelijk”);

★ Aan de slag 58

    1. Ontwerp de interface zoals hiernaast is aangegeven.
    2. Gebruik de volgende namen voor de objecten:
      intKnop, stringKnop, invoerVeld en resultaatVeld
    3. Neem de code voor de event-handler van de intKnop over:
      public void intKnopActionPerformed(ActionEvent evt) {
      int x = Integer.parseInt(invoerVeld.getText());
      int y = Integer.parseInt(invoerVeld.getText());
      if (x == y)
        resultaatVeld.setText("Gelijk!");
      else
        resultaatVeld.setText("Verschillend!");
      }
    4. Neem de code voor de event-handler van de stringKnop over:
      public void stringKnop_ActionPerformed(ActionEvent evt) {
      String x = invoerVeld.getText();
      String y = invoerVeld.getText();
      if (x == y)
        resultaatVeld.setText("Gelijk!");
      else
        resultaatVeld.setText("Verschillend!");
      }
    5. Typ een getal in het invoerVeld.
    6. Druk op de int-knop.
      Wat is het resultaat?
    7. Druk op de String-knop.
      Wat is het resultaat?
    8. Welke conclusie trek je uit de bovenstaande resultaten?
       
  2. Pas de event-handler van de stringKnop aan, zodat deze wel het gewenste resultaat oplevert.

PalindroomApplet

Een palindroom is een woord dat je ook van achter naar voor kunt lezen. Het volgende applet controleert of een woord een palindroom is. Voorbeelden van dergelijke woorden zijn kok, lepel, kayak, parterretrap. Het applet heeft een invoerveld waar het woord wordt ingetypt. In een label wordt aangegeven of het woord een palindroom is of niet. In het applet wordt een aantal methoden uit de klasse String gebruikt. Voor de controleerKnop moet je een event-handler schrijven.
De code hiervoor is:

String woord = invoerVeld.getText();
int aantal = woord.length();
String omgekeerd = "";
for (int index = 0; index < aantal; index ++) {
  String letter = woord.substring(index, index + 1);
  omgekeerd = letter + omgekeerd;
}
if (woord.equals(omgekeerd))
  uitvoerLabel.setText("Palindroom");
else
  uitvoerLabel.setText("Geen palindroom");

★ Aan de slag 59

  1. Ontwerp de interface voor het PalindroomApplet.
  2. Voer de event-handler in.

Gebruik methoden

In de tweede regel geeft de methode length() als resultaat het aantal tekens van de string.
Deze methode heeft als resultaattype een int en heeft geen argument: int length().
In regel 4 staat een for-lus, die er voor zorgt dat het woord letter voor letter wordt langs gelopen. De variabele index geeft de positie van de letter in een string aan. De eerste letter staat op positie 0!
In regel 5 wordt met behulp van de methode substring een letter uit het woord gehaald. De methode substring geeft als resultaat een string die een deel is van de oorspronkelijke string. Deze methode heeft als resultaattype een String en heeft twee argumenten van het type int, die het begin en het einde van de string markeren:

String substring(int, int)

★ Aan de slag 60

  1. In het PalindroomApplet wordt de methode length() gebruikt.
    1. Van welke klasse is length() een methode?
    2. Wat is het resultaattype van de methode length()?
       
  2. In de for-lus van het PalindroomApplet staat de logische expressie index < aantal. Waarom niet index <= aantal?
     
  3. De methode substring() uit de klasse String heeft twee argumenten van het type int: String substring(int, int).
    1. Wat geeft het eerste argument aan?
    2. Wat geeft het tweede argument aan?

Concatenatie Strings

In regel 6 van de broncode van de event-handler van de controleerKnop van het PalindroomApplet worden twee strings aan elkaar “geplakt” met behulp van het plusteken. Dit wordt concatenatie (aaneenschakeling) van strings genoemd. Bekijk het volgende voorbeeld:

String voornaam = “Alan”;
String achternaam = “Turing”;
uitvoerVeld.setText(voornaam + “ “ + achternaam);

Ook is het mogelijk om op deze manier strings en getallen achter elkaar te plakken.
Het resultaat is weer een string:

String adres = 1011 + “ ENIGMA-way”;

In regel 8 worden twee strings met elkaar vergeleken met de methode equals. Deze methode heeft als resultaattype een boolean en heeft als argument een String: boolean equals(String).

★ Aan de slag 61

  1. Wat betekent de concatenatie van strings?

  2. In het PalindroomApplet worden twee strings met elkaar vergeleken met de methode equals().

    1. Met welke andere methode kun je twee strings vergelijken? (Kijk in de bijlage bij de inleiding)
    2. Wat is het verschil tussen beide methodes?

Conversie Strings

Om een getal naar een string te converteren, kent de klasse String de methode valueOf(). Deze methode kan als argument een variabele van het type int hebben, maar ook van het type double. Het resultaat is van het type String:

int getal = 1234;
double resultaat = 12.34;
String tekstGetal = String.valueOf(getal);
String tekstResultaat = String.valueOf(resultaat);
uitvoerVeld.setText(tekstGetal+ “ “ + tekstResultaat);

Omgekeerd moet het ook mogelijk zijn om van een string een getal te maken. Als eerste bekijken we de conversie van String naar int. De klasse Integer bevat een methode parseInt() die als argument een variabele van het type String heeft. Het resultaat is van het type int:

int getal = Integer.parseInt(“5“);

Voor de conversie naar double kent Java de methode parsedouble() uit de klasse Double. Deze methode heeft als argument een variabele van het type String. Het resultaat is van het type double:

double resultaat = Double.parseDouble(“12.34“);

Alleen strings die een int-waarde voorstellen kunnen worden geconverteerd: “5” Wanneer een string niet de juiste vorm heeft en je in bovenstaand voorbeeld in plaats van 5 “ENIGMA” invult, levert dit een foutmelding (Exception) tijdens de verwerking van het programma op.

In de klasse String zit een groot aantal methoden, waar elke instantie van de klasse String gebruik kan maken. Een aantal methoden hebben we de revue laten passeren, zoals length(), substring(), equals() en valueOf(). In de bijlage bij deze module vind je een overzicht van een aantal veelgebruikte methoden uit de klasse String.

Toets 2

In de volgende toets wordt getoetst wat je inmiddels zou moeten weten over het onderwerp programmeren in Java.
Klik op de link en maak de toets:

Strings

★ Aan de slag 62

  1. Op welke manier kan een getal naar een string worden geconverteerd?
  2. Op welke manier kan een string naar een getal worden geconverteerd?

★ Aan de slag 63

In deze opdracht moet je een applet schrijven dat uit een woord de klinkers ( de letters e, a, o, i, u) haalt. De gebruiker moet eerst een woord intypen. Het applet loopt het woord letter voor letter langs en controleert of een letter een klinker. Als het geen klinker is dan moet de letter meegenomen worden naar het nieuwe woord.

 

★ Aan de slag 64

Schrijf een applet die alleen de letters op de oneven posities in een woord toont.

★ Aan de slag 65

Je krijgt de opdracht om een codeermachine te bouwen.

De machine werkt als volgt: Een gebruiker typt in het normaalVeld een tekst in. Door op de knop Codeer te klikken verschijnt de tekst in het codeerVeld. Om te decoderen klikt de gebruiker op de knop Decodeer. De gecodeerde tekst in het codeerVeld wordt weer gecodeerd teruggeplaatst in het normaalVeld.

Het algoritme om de tekst te coderen luidt als volgt: Je loopt de tekst door en je begint bij de eerste letter (positie 0). Dan sla je een letter over en je neemt de letter op positie 2. Zo ga je door totdat je aan het eind van de tekst bent aangekomen.

Vervolgens ga je terug naar het begin van de tekst. Dan neem je de tweede letter (positie 1). Je slaat een letter over en je neemt de letter op positie 3. Wanneer je weer aan het eind van de tekst bent aangekomen heb je de tekst gecodeerd.

★ Aan de slag 66

Het applet hiernaast zet gehele getallen om in Romeinse cijfers. De Romeinen gebruikten de volgende symbolen voor hun getallen:

I 1
V 5
X 10
L 50
C 100
D 500
M 1000
  1. Hoe worden de volgende getallen in Romeinse cijfers genoteerd?
    14
    19
    148
    1954
  2. Schrijf een applet dat een geheel getal tot en met 3000 omzet naar Romeinse cijfers. Kijk in het overzicht van methoden voor methoden van de klasse String.

 

Exceptions

In het applet die gehele getallen omzet naar Romeinse cijfers moet de invoer uit cijfers bestaan. Wanneer de gebruiker van het applet bijvoorbeeld vijftien in plaats van 15 zal dat tot een foutmelding leiden. Hetzelfde gebeurt als de gebruiker niets intypt. De programmeur moet dit soort fouten van de gebruiker afvangen. In Java worden deze fouten exceptions genoemd. We bekijken het volgende programmacode:

try {
   double inkomsten = Double.parseDouble(inkomstenVeld.getText());
   double uitgaven = Double.parseDouble(uitgavenVeld.getText());
   saldoVeld.setText(String.valueOf(inkomsten-uitgaven));
}
catch (NumberFormatException e) {
   foutmeldingLabel.setText("Ongeldige invoer");
}

De gebruiker moet in het inkomstenveld en het uitgavenveld zijn inkomsten en uitgaven intypen. Het programma berekent vervolgens het saldo. Wanneer de gebruiker echter geen getal intypt dan gaat het mis, want de methode valueOf() kan de string niet omzetten naar een getal. Om dit op te lossen wordt hier een statement gebruikt dat de fouten afvangt. De vorm van dit statemant zie je op de volgende pagina.

try {
   een serie statements
}
catch (eenException e) {
   afhandeling van de exception
}

In het try-blok worden de statements uitgevoerd. Wanneer er geen exception optreedt, dan wordt het catch-blok genegeerd. Als er wel een exception optreedt, dan kunnen we specificeren dat het catch-blok moet worden uitgevoerd door de klasse van exception aan te geven die we willen opvangen: NumberFormatException. (In de API Reference staat aangegeven dat bij een exception de methode parseDouble() van de klasse Double een component van de klasse NumberFormatException produceert.) Als er een ander soort exception optreedt, wordt de catch niet uitgevoerd.

 

★ Aan de slag 67

Pas het applet van de Romeinse getallen aan zodat het applet bestand is tegen onjuiste invoer.

Voortgang

Bekijk hier je voortgang

Kernprogramma


Docent kan klassen aanmaken en leerlingen volgen
Een docent kan op de profielpagina klassen aanmaken. Als een docent dat gedaan heeft, kunnen de leerlignen zich aan de klas koppelen. Als de leerlingen dat gedaan hebben, kan de docent de voortgang van de leerlingen volgen.

>> Profielpagina

  • Het arrangement Programmeren met Java kopie is gemaakt met Wikiwijs van Kennisnet. Wikiwijs is hét onderwijsplatform waar je leermiddelen zoekt, maakt en deelt.

    Auteur
    Alien Siero
    Laatst gewijzigd
    2020-01-02 10:28:49
    Licentie

    Dit lesmateriaal is gepubliceerd onder de Creative Commons Naamsvermelding 4.0 Internationale licentie. Dit houdt in dat je onder de voorwaarde van naamsvermelding vrij bent om:

    • het werk te delen - te kopiëren, te verspreiden en door te geven via elk medium of bestandsformaat
    • het werk te bewerken - te remixen, te veranderen en afgeleide werken te maken
    • voor alle doeleinden, inclusief commerciële doeleinden.

    Meer informatie over de CC Naamsvermelding 4.0 Internationale licentie.

    Aanvullende informatie over dit lesmateriaal

    Van dit lesmateriaal is de volgende aanvullende informatie beschikbaar:

    Toelichting
    programmeren met Java kopie
    Eindgebruiker
    leerling/student
    Moeilijkheidsgraad
    gemiddeld
    Studiebelasting
    4 uur 0 minuten

    Gebruikte Wikiwijs Arrangementen

    Siero, Alien. (z.d.).

    Programmeren met Java - kopie 1

    https://maken.wikiwijs.nl/155281/Programmeren_met_Java___kopie_1

  • Downloaden

    Het volledige arrangement is in de onderstaande formaten te downloaden.

    Metadata

    LTI

    Leeromgevingen die gebruik maken van LTI kunnen Wikiwijs arrangementen en toetsen afspelen en resultaten terugkoppelen. Hiervoor moet de leeromgeving wel bij Wikiwijs aangemeld zijn. Wil je gebruik maken van de LTI koppeling? Meld je aan via info@wikiwijs.nl met het verzoek om een LTI koppeling aan te gaan.

    Maak je al gebruik van LTI? Gebruik dan de onderstaande Launch URL’s.

    Arrangement

    IMSCC package

    Wil je de Launch URL’s niet los kopiëren, maar in één keer downloaden? Download dan de IMSCC package.

    Voor developers

    Wikiwijs lesmateriaal kan worden gebruikt in een externe leeromgeving. Er kunnen koppelingen worden gemaakt en het lesmateriaal kan op verschillende manieren worden geëxporteerd. Meer informatie hierover kun je vinden op onze Developers Wiki.

  • Gebruik
    Weergave
  • Wikiwijs is een dienst van