inhoudstafel en auteursrecht
* STER *

2. Basisconstructies

2.1 Blok

Programma- en gegevensstructuren zijn in Java niet strikt van elkaar gescheiden. Dat is een gevolg van het object-georiënteerd karakter van deze programmeertaal. Object-georiënteerd programmeren omvat ondermeer encapsulatie: interne toestand en uitwendig gedrag van een object zitten verenigd in één structuur.

De basiseenheid waarin Java-structuren worden uitgedrukt is het blok. Een blok is herkenbaar aan een paar accoladen. Wat zich tussen een paar accoladen bevindt, hoort op een of andere manier bij elkaar. Blokken kunnen in elkaar genesteld liggen: een groot blok kan een kleiner blok bevatten.

Oefening 2.1

Ga na hoe in het voorbeeldprogramma van paragraaf 1.2 de accoladen gerangschikt zijn. Tracht deze werkwijze te formuleren als een algemene regel.

Oplossing

2.2 Klasse

Een geldig Java-programma bestaat uit een opsomming van klassen. In object-georiënteerd programmeren vertegenwoordigt een klasse een verzameling objecten van hetzelfde type.

De inhoud van elk Java-programmabestand is gewoon een opsomming van een of meer klassendefinities.

Het voorbeeldprogramma van paragraaf 1.2 bevat precies één klasse met de naam Hallo. Het blok dat daarop volgt (alles wat tussen de buitenste aanhalingstekens staat), definieert de inhoud van de klasse. We houden ons voorlopig niet bezig met de betekenis van de regel

  public static void main(String[] args) {

maar we aanvaarden gewoon dat elk zelfstandig Java-programma een dergelijk main-blok bevat. Binnen de accoladen van het main-blok staan de opdrachten van het programma.

2.3 Veranderlijke

Een veranderlijke is een symbolische weergave van een gegeven in het geheugen van de computer (getallen, teksten of meer ingewikkelde structuren). In Java heeft elke veranderlijke een type dat het soort gegevens bepaald dat in die geheugencel mogen opgeslagen worden.

We geven het type van een veranderlijke aan door een declaratie, dat is een regel van de vorm

<typenaam> <veranderlijke> ;

Enkele voorbeelden van geldige typenamen zijn:

• int voor gehele getallen
• double voor getallen met vlottende komma
• String voor teksten (reeksen van karakters)

Het is ook mogelijk, meer dan één veranderlijke van hetzelfde type te declareren in énén declaratie, op voorwaarde dat ze hetzelfde type hebben:

<typenaam> <veranderlijke1> , <veranderlijke2>, ... ;

Voorbeeld

De volgende declaraties zeggen dat de veranderlijken x, y en temp gehele getallen zijn, terwijl naam4 een karakterstreng is.

int x, temp;
String naam4;
int y;

2.4 Toekenning

We gebruiken de toekenningsopdracht om een waarde toe te kennen aan de geheugenruimte waarnaar een veranderlijke verwijst. De algemene vorm van de toekenning is

<veranderlijke> = <uitdrukking> ;

Hierbij staat <uitdrukking> voor een constante (bijvoorbeeld 8, of 3.14159, of "informatica"), een veranderlijke (dezelfde of een andere), of een complexere uitdrukking die wordt opgebouwd aan de hand van bewerkingstekens.

Voorbeeld

De volgende reeks opdrachten kent eerst aan temp de waarde 3 toe. De inhoud van x wordt gelijkgesteld aan één eenheid hoger, dus 4. Daarna verdubbelen we de inhoud van temp, en tenslotte wordt aan y de inhoud van temp min vier toegekend.

temp = 3;
x = temp + 1;
temp = temp * 2;
y = temp - 4;

Oefening 2.2

Wat is de inhoud van y na afloop van bovenstaande reeks opdrachten ?

Oplossing

2.5 Bewerkingen

Complexe uitdrukkingen kunnen dus worden samengesteld uit eenvoudige uitdrukkingen door middel van bewerkingen. Java kent vele bewerkingstekens, waarvan we er hier enkele kort beschrijven:

• rekenkundige bewerkingen: +, -, * en / hebben hun gewone betekenis van optelling, aftrekking, vermenigvuldiging en deling. Tussen twee gehele getallen is / de gehele deling, als het linker- of het rechterlid decimalen heeft, dan wordt de deling ook opgevat als een deling met decimalen. Bij gehele getallen bestaat ook het bewerkingsteken % (percentteken) voor de rest van de deling.
• samenstelling van strengen: wanneer links of rechts van een plusteken een karakterstreng staat, dan betekent het plusteken de concatenatie (samenvoeging) van strengen.

Met behulp van haakjes kan je de volgorde der bewerkingen controleren, net als in de algebra.

Voorbeeld

De volgende twee opdrachten drukken verschillende teksten op het scherm:

System.out.println("Resultaat: " + (3 + 4));
System.out.println(("Resultaat: " + 3) + 4);

In het eerste geval wordt het laatste plusteken rekenkundig opgevat omdat het tussen twee getallen staat. In de tweede regel zijn allebei de plustekens concatenaties.

Oefening 2.3

Schrijf een Java-programma met de naam PlusTest dat bovenstaande twee opdrachten uitvoert. Controleer het resultaat.

Oplossing

2.6 Invoer langs het toetsenbord

We gaan later nog in op het algemene gebruik van invoer/uitvoer in Java-programma's. De bedoeling van deze paragraaf is uitsluitend het noodzakelijkste bij te brengen om eenvoudige gegevensinvoer via het toetsenbord mogelijk te maken.

In een programma dat het toetsenbord gebruikt, moet een referentie bestaan naar een object van het type BufferedReader, bijvoorbeeld in de vorm van een gedeclareerde veranderlijke:

BufferedReader toetsenbord;

Aan deze referentie kennen we de volgende uitdrukking toe, waarvan de precieze betekenis pas later zal duidelijk worden:

new BufferedReader(new InputStreamReader(System.in));

Bovenstaande uitdrukking zal pas door de compiler worden aanvaard als we helemaal bovenaan in het bronbestand, vóór de eerste klassendeclaratie, de volgende regel opnemen:

import java.io.*;

De inhoud van een regel invoer van het toetsenbord bekomen we door de uitdrukking

toetsenbord.readLine()

waarbij toetsenbord kan vervangen worden door de referentie die men eerder gedeclareerd heeft (zie hierboven). Opeenvolgende regels bekom je door deze uitdrukking verschillende keren na elkaar op te roepen. Ze is van het gegevenstype String en kan dus als volgt worden opgevangen:

String gelezen;
gelezen = toetsenbord.readLine();

De hoofding van de main-methode (eigenlijk: van elke methode die readLine() gebruikt, moet worden voorzien van de tekst throws IOException als waarschuwing voor eventuele fouten bij het lezen van de invoer, en wel als volgt:

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

Voorbeeld

Het volgende programma leest drie regels tekst en plaatst ze achter elkaar op het scherm, gescheiden door spaties.

/* Noodzakelijk opdat de compiler de namen
   BufferedReader en InputStreamReader zou
   herkennen. */
import java.io.*;

class AchterElkaar {
  /* We waarschuwen de compiler dat IOException kan optreden
     bij het gebruik van readLine(). */
  public static void main(String[] args) throws IOException {
    // Declareer een veranderlijke van het type BufferedReader.
    BufferedReader toetsenbord;

    // Ken er een welbepaalde uitdrukking aan toe.
    toetsenbord = new BufferedReader(new InputStreamReader(System.in));

    // Lees drie regels tekst.
    String woord1, woord2, woord3;
    woord1 = toetsenbord.readLine();
    woord2 = toetsenbord.readLine();
    woord3 = toetsenbord.readLine();

    // Druk ze achter elkaar af, gescheiden door spaties.
    System.out.println(woord1 + " " + woord2 + " " + woord3);
  }
}

Heel vaak willen we van de gebruiker geen tekstuele, maar numerieke invoer, d.w.z. getallen. Dit kan alleen onrechtstreeks, namelijk door eerst een tekst te lezen, hopend dat de gebruiker alleen maar cijfers en een eventuele komma invoert, en vervolgens de bekomen String om te zetten naar een int of een double.

Om de streng eentekst om te zetten naar een geheel getal, gebruiken we de uitdrukking

Integer.parseInt(eentekst)

Voor de omzetting naar double is er de uitdrukking

Double.parseDouble(eentekst)

Voorbeeld

Het volgende programma vraagt van de gebruiker een netto-verkoopprijs en een BTW-percentage. Het berekent vervolgens het bedrag van de BTW en de verkoopprijs inclusief BTW.

import java.io.*;

class BTW {
  public static void main(String[] args) throws IOException {
    BufferedReader toetsenbord;
    toetsenbord = new BufferedReader(new InputStreamReader(System.in));

    // Vraag en krijg nettoprijs
    System.out.println("netto verkoopprijs ?");
    String nettoTekst;
    nettoTekst = toetsenbord.readLine();
    double nettoBedrag;
    nettoBedrag = Double.parseDouble(nettoTekst);

    // Vraag en krijg BTW-voet
    System.out.println("BTW-voet (in percent) ?");
    String btwTekst;
    btwTekst = toetsenbord.readLine();
    double btwPercent;
    btwPercent = Double.parseDouble(btwTekst);

    // Bereken resultaten en druk af
    double btwBedrag;
    btwBedrag = nettoBedrag * btwPercent / 100;
    double brutoBedrag;
    brutoBedrag = nettoBedrag + btwBedrag;
    System.out.println("bedrag BTW: " + btwBedrag);
    System.out.println("bruto verkoopprijs: " + brutoBedrag);
  }
}

Oefening 2.4

Schrijf een Java-programma Deling.java dat twee gehele getallen leest en achtereenvolgens afdrukt:

• het quotiënt en rest van de gehele deling
• de verhouding, uitgedrukt als een getal met cijfers na de komma

Oplossing

inhoudstafel en auteursrecht
* STER *