In dit hoofdstuk zullen we de absolute basis van de Java syntaxis onder de loep nemen. We gaan nog niet te diep in op het gebruik van alles, we zullen ons bezig houden met zeer rudimentaire programma's. De absolute basis van het programmeren in Java dus!

Hallo wereld

We gaan nu ons eerste Java programma schrijven, en zo leren werken met de compiler. Hoe je de compiler moet installeren vind je in appendix A.

Typ onderstaande code in (let op de hoofdletters, Java is hoofdlettergevoelig). Dit moet gebeuren in een programma dat de code als een tekstbestand opslaat. In Windows is dit bijvoorbeeld Kladblok. In Mac kan je TextEdit gebruiken. Sla de code op in een bestand met de naam Hallo.java.

 1: public class Hallo {
 2:    public static void main(String[] args) {
 3:      System.out.println("Hallo wereld!");
 4:    }
 5:  }

javac Hallo.java

java Hallo

 1: public class Hallo {
 2:    public static void main(String[] args) {
 3:      System.out.println("Hallo wereld!");
 4:    }
 5:  }

Primitieve variabelen

Nu willen we toch graag wat meer doen dan enkel een tekst weergeven. We zullen ons eerste programma een beetje opfleuren met een wiskundige berekening met veranderlijken:

 1: public class Hallo {
 2:  public static void main(String[] args) {
 3:    int a;
 4:    int b;
 5:    int c;
 6:    a = 1;
 7:    b = 2;
 8:    c = a + b;
 9:    System.out.println("1 + 2 = " + c);
10:  }
11: }

Op regel 3 tot 5 maken we drie variabelen aan met respectievelijk de namen a, b en c. Dit doen we via het sleutelwoord int, wat de afkorting is voor integer (je mag echter nooit integer voluit schrijven bij declaratie van een variabele). Dit sleutelwoord bepaalt welk soort variabele we aanmaken. Het aanmaken van een variabele noemen we declareren. Het vertelt de compiler dat we een variabele gaan gebruiken met een bepaalde naam en van een welbepaald type. Het declareren van variabelen is in Java verplicht. Als dat niet gebeurt, dan levert dat een foutmelding op tijdens het compileren.

We kunnen nog op een andere manier een reeks variabelen van hetzelfde type declareren door regel 3 tot 5 te schrijven als:

int a, b, c;

Deze laatste manier zorgt voor iets compactere code, maar is verder identiek.

Op regel 6 en 7 geven we zowel de variabele a als b een waarde. Men mag niet eender wat na het gelijkaanteken zetten (zie verder). De actie die we ondernemen heet initialiseren omdat we voor de eerste keer de variabelen een waarde toekennen. Het gelijkaanteken noemen we de toekenningsoperator en lees je best als "wordt" (en niét als "is").

Op regel 8 initialiseren we de variabele c. Niet met een door ons bepaalde waarde maar met de som van de twee variabelen a en b. Het plus-teken is een wiskundige operator.

Op regel 9 tonen we een woord op het scherm zoals we eerder al deden. Dat woord is "1 + 2 = ". Daarna schrijven we een plus-teken. Dit keer is de plus geen wiskundige operator maar een speciale "concatenatie"-operator die voor het aaneenzetten van tekst wordt gebruikt (zie het hoofdstuk over Stringbewerkingen).

In Java zitten een paar vaste sleutelwoorden zoals int die bepaalde types van variabelen bevatten. Variabelen die niet meer doen dan één bepaalde waarde opslaan noemen we primitieve variabelen. Deze zijn door Java gedefinieerd en de programmeur kan er geen nieuwe bijmaken. Er zijn in totaal negen primitieve variabelen. Iedere soort staat voor een eigen type. Hieronder zie je alle primitieve typen:

Sleutelwoord	Betekenis	Aantal bits	Bereik	Voorbeeld
boolean	booleaanse waarde	1	true of false	boolean a = true;
byte	heel klein geheel getal	8	-128 (-27) tot 127 (27 - 1)	byte b = 8;
char	karakter	16	Alle Unicode-tekens	char c = 'a';
short	klein geheel getal	16	-32768 (-215) tot 32767 (215 - 1)	short d = 658;
int	geheel getal	32	-2147483648 (-231) tot 2147483647 (231 - 1)	int e = 2000000;
long	groot geheel getal	64	-263 tot 263 - 1	long f = 220000000;
float	reëel getal	32	±${\displaystyle 0,14*10^{-64}}$ tot ±${\displaystyle 0,34*10^{39}}$	float g = 89.567;
double	reëel getal (dubbele precisie)	64	±${\displaystyle 0,49*10^{-325}}$ tot ±${\displaystyle 0,18*10^{309}}$	double h = 1000.987;
void	niets	-	-	void methode() { }

Variabelen verschillen onderling van formaat, zo zijn er variabelen voor letters (ASCII-karakters), voor gehele getallen (bijvoorbeeld int), voor kommagetallen (double), ...

Ze verschillen daarbij ook nog in de hoeveelheid bits ze in het geheugen innemen. Een gewone int bevat bijvoorbeeld 32 bits ofwel 4 bytes. Andere gehele types zoals bijvoorbeeld short zijn 16 bits, of long (64 bits) groot. Wanneer je grote getallen wilt opslaan, kun je bijvoorbeeld beter een variabele van het long-type gebruiken dan van short. Je denkt hier het best altijd eerst even over na, zodat je niet overbodig veel ruimte inneemt (ook al is deze maar enkele bytes groter).

De primitieve variabele void is speciaal. Deze wordt vooral gebruikt om aan te duiden dat een methode niets teruggeeft (zie later). We zullen hem niet direct nodig hebben, onthoud enkel dat het eigenlijk staat voor niets.

Operatoren

In java laat een operator je toe (wiskundige) bewerkingen uit te voeren met variabelen. We onderscheiden drie grote groepen operatoren: wiskundige (+, -, *, /, %), logische (&&, ||, !) en relationele (>, <, ==). Daarnaast hebben String-objecten nog een speciale "+" operator ter beschikking waarmee je verschillende Strings tot één String kunt "concateneren" (samenvoegen).

De meeste operatoren doen bewerkingen op twee variabelen, dit noemen we binaire operatoren. Er zijn er ook die op één variabele werken, de zogenaamde unaire operatoren. Er zijn slechts vier unaire operatoren: "+" en "-" als toestandsteken en "++" en "--", waarover later meer.

We zijn al drie (binaire) operatoren tegengekomen: De speciale String "+" operator, de wiskundige "+" operator en de "=" operator die een waarde toekent aan een variabele. Hieronder volgt een lijstje van alle operatoren en een voorbeeld van hun gebruik. Let erop dat je meestal verschillende operatoren tegelijk gaat gebruiken (bv. a = b + c;).

Alle operatoren in java:

 1: int a = 5;
 2: a += 5;
 3: System.out.println(a);

 1: int a = 5;
 2: a = a + 5;
 3: System.out.println(a);

 1: public class IncrementKort {
 2:  public static void main(String[] args) {
 3:    int a = 1, b = 2, c, d;
 4:    c = ++a; // a = 2, c = 2
 5:    c = a++; // a = 3, c = 2 (!)
 6:    d = --b; // b = 1, d = 1
 7:    --b;     // b = 0
 8:    ++b;     // b = 1
 9:    b++;     // b = 2
10:  }
11:}

 1: public class IncrementLang {
 2:  public static void main(String[] args) {
 3:    int a = 1, b = 2, c, d;  
 4:    a = a + 1; // Deel 1 van: c = ++a;
 6:    c = a;     // Deel 2 van: c = ++a;
 7: 
 8:    c = a;     // Deel 1 van: c = a++;
 9:    a = a + 1; // Deel 2 van: c = a++;
10:  
11:    b = b - 1; // Deel 1 van: d = --b;
12:    d = b;     // Deel 2 van: d = --b;
13:  
14:    b = b - 1; // --b;
15:    b = b + 1; // ++b;
16:    b = b + 1; // b++;
17:  }
18:}

 1: public class Precedentie {
 2:   public static void main (String[] args) {
 3:      int a = 2, b = 3, c = 4, d = 2, e = 1;     // initialiseer enkele variabelen
 4:      double resultaat;                    // declareer een double met de naam "resultaat"
 5:      resultaat = (a+b)*c-b/e+(c-d)*a++;   // een reeks bewerkingen
 6:   }
 7: }

Conditioneel programmaverloop

Computerprogramma's zijn weinig zinvol als ze altijd hetzelfde doen. Afhankelijk van het resultaat is het interessant om de loop van het programma aan te passen. In Java kun je gebruik maken van de statements: if, else en else if.

Het gebruik van if gaat als volgt:

if( <boolean> ) { ... }

Tussen de accolades komt de code die moet worden uitgevoerd als de boolean true is. De boolean kan je verkrijgen uit het resultaat van bijvoorbeeld de == operator. Je kijkt of het resultaat van de bewerking true is en voert vervolgens een gewenste bewerking uit. Zo zal de code onder "if(4 < 5) { ... }" altijd uitgevoerd worden (daar 4 altijd kleiner is dan 5).

Let erop dat tussen de accolades een willekeurige hoeveelheid programmacode kan komen (net zoals de accolades bij een methode). Tussen de accolades vind je namelijk een code block. Dat is een blok waarbinnen je code kan groeperen. Als het if-statement true evalueert zal hij de volledige blok code tussen de accolades uitvoeren.

Na een if kan je else gebruiken om de code te bepalen die enkel wordt uitgevoerd indien de boolean false was:

if( <boolean> ) { ...}
else { ... }

Je ziet dat er bij else geen nieuwe boolean gevraagd wordt. Een else-statement komt altijd onmiddellijk na een if-statement. Tenzij je gebruik maakt van "else if" op de volgende manier:

if( <boolean> ) { ... }
else if( <boolean2> ) { ... }
else { ... }

In de geest van een praktische aanpak, hieronder een codevoorbeeld. We maken een programma dat de absolute waarde van het verschil tussen twee getallen op het scherm toont.

 1: public class AbsoluutVerschil {
 2:   public static void main(String[] args) {
 3:     int a = 19, b = 9;
 4:     int verschil = 0;
 5:
 6:     if(a > b) {
 7:       verschil = a - b;
 8:     } else {
 9:       verschil = b - a;
10:     }
11:
12:     System.out.println("Het verschil tussen " + a + " en " + b + " is: " + verschil);
13:   }
14: }

In bovenstaand programma kan zowel a groter zijn dan b of b groter dan a. Het zal niets echter niets uitmaken voor het verschil.

Op regel 6 zien we de vergelijking a > b. We maken gebruik van de "groter dan" relationele operator die als resultaat een boolean heeft en dus geschikt is om tussen haakjes van if te staan.

Op regel 7 zien we wat er moet gebeuren indien a groter is dan b. Dan trekken we b van a af zodat het resultaat positief blijft. Indien b groter is dan a moet het omgekeerde gebeuren. Dat zien gebeurt op regel 8 en 9.

Op regel 8 zien we dat de sluitende accolade van het if-statement op dezelfde regel staat als het begin van het else-statement. Dit is een kwestie van stijl, je kan de else ook een regel eronder beginnen. De java compiler is daar blind voor.

Op regel 12 schrijven we de waarde van de twee variabelen en hun onderling verschil uit.

Nog een kleine opmerking. Indien tussen de haakjes slechts 1 code-instructie staat (1 code-instructie is van het begin van een instructie tot aan de eerste ";") kunnen we de accolades weglaten omdat we geen blok code moeten uitvoeren maar slechts 1 instructie. Maar dat is wederom een kwestie van stijl, in het begin laat je best voor alle duidelijkheid de accolades staan.

Naast de if - elsesequentie kan je ook op een alternatieve manier voorwaardelijk code uitvoeren. Stel je de volgende situatie voor: de gebruiker beschikt over een serie knoppen, elke knop geeft een variabele een uniek nummer bij het indrukken. Om dan te kijken welke knop is ingedrukt kan je de waarde van die variabele bekijken. Per knop moet je een andere actie uitvoeren. Je kan werken met een reeks if en else if statements, maar java heeft nog een andere structuur speciaal voor dit soort gevallen: De switch case. We bekijken de werking door middel van een voorbeeldje:

 1: public class Switch {
 2:   public static void main(String[] args) {
 3:     int waardeKnop = 1; // knop 1 is ingedrukt
 4:     switch(waardeKnop) {
 5:       case 1:
 6:         System.out.println("Knop 1 werd ingedrukt.");
 7:         break;
 8:       case 2:
 9:         System.out.println("Knop 2 werd ingedrukt.");
10:         break;
11:       case 3:
12:         System.out.println("Knop 3 werd ingedrukt.");
13:         break;
14:       default:
15:         System.out.println("Fout: Een onbekende knop werd ingedrukt!");
16:     }
17:   }
18: }

Op regel 3 maken we een variabele aan die de waarde meegegeven door onze knop moet voorstellen, probeer eens verschillende waarden uit.

Op regel 4 geven we die variabele mee aan het switch-statement. We openen ook een codeblok.

Op regel 5 schrijven we case gevolgd door een spatie en dan een mogelijke waarde van de variabele die we mee gaven aan het switch statement. Daarna een dubbele punt. Indien nu de variabele waardeKnop de waarde 1 heeft, zal wat na de dubbele punt komt worden uitgevoerd, indien niet zal de code spring naar regel 8.

Op regel 6 schrijven we gewoon een melding naar het scherm.

Op regel 7 zien we een heel belangrijk sleutelwoord voor switches: "break;" zorgt ervoor dat er gesprongen wordt tot de eerstvolgende instructie na de sluitende accolade van het switch blok. Dus naar regel 17 in ons voorbeeld, je stapt als het ware uit de switch. Dit is belangrijk want als "break;" er niet staat zal er doorgegaan worden met uitvoeren naar regel 8 maar de waarde van de variabele zal niet meer worden gecontroleerd, en wat na de dubbele punt van regel 8 staat zal ook worden uitgevoerd. Hier is dit niet gewenst, maar het is wel handig als je voor een groep waarden dezelfde code wil uitvoeren, mits nog iets extra per waarde. Als we bijvoorbeeld de break op regel 7 wegnemen zal wanneer de waarde van de knop 1 is zowel op het scherm komen dat knop 1 en knop 2 zijn ingedrukt, als de waarde 2 is zal er echter enkel op komen dat knop 2 is ingedrukt, aangezien er op regel 10 wel een "break;" staat. Test dit maar eens door regel 7 uit te commentariëren.

Hetzelfde systeem herhaalt zich tot regel 14. Wat daar na het dubbelpunt komt wordt enkel uitgevoerd indien de waarde van de variabele in bovenstaande cases niet is gevonden. Hier zal dit dus uitgevoerd worden wanneer de waarde van waardeKnop niet 1, 2 of 3 is.

Opgelet: de switch werkt enkel met int variabelen. Je kan wel de meeste andere primitieve types gebruiken maar zij worden allemaal omgezet naar int, het is dus best bij int te blijven.

Of je in een bepaald geval beter een "if"- dan wel een "switch"-statement gebruikt moet je zelf bepalen. Duidelijke regels of afspraken hieromtrent bestaan niet.

Loops

Ook in de Java programmeertaal is het mogelijk om een bewerking te herhalen. Daar zijn natuurlijk een aantal methoden voor. Zo heb je de "for"-lus, de "while"-loop, en sinds versie 1.4 ook de iteraties. Sinds versie 5 is er ook de "enhanced" "for"-loop, die het mogelijk maakt om gemakkelijk door arrays of collections te lopen (zie de betreffende hoofdstukken).

1: public class ForTest {
2:    public static void main (String args[]) {
3:        for (int i=0; i < 5; i++ ) {
4:            if (i==0) System.out.println ("i heeft de waarde "+i);
5:            if (i > 0) System.out.println("plus 1 is "+i);
6:            if (i == 4) System.out.println("Aan het einde van deze lus heeft i de waarde "+i);
7:        }
8:    }
9:}

 1: public class WhileTest {
 2:   public static void main(String[] args) {
 3:       int i=0;
 4:       System.out.println("i heeft de waarde "+i);
 5:       while (i<5) { 
 6:           i++;
 7:           System.out.println("plus 1 is "+i);
 8:       }
 9:       System.out.println("Aan het einde van deze lus heeft i de waarde "+i);
10:   }
11: }

Arrays

Een array is een groep van variabelen die als één geheel kan worden benaderd. Om bijvoorbeeld een groep van int variabelen te declareren die de maximale dagtemperaturen in een een jaar kan bevatten kan

1: int[] maxima = new int[365];

Deze code maakt een array aan met 365 elementen van het type int. Elk element in een array is op te vragen door een index te gebruiken:

1: int maximumDag1 = maxima[0];

In het voorgaande fragment krijgt de variabele maximumDag1 dezelfde waarde als het eerste element in de array maxima. Merk op dat een array index begint bij 0. De maximale waarde die een array index mag hebben is gelijk aan het aantal elementen in de array - 1. Het opvragen van een element door een index te gebruiken met een waarde buiten deze grenzen resulteert in een fout. De grootte van een array is op te vragen:

1: System.out.println("Grootte van maxima array:" + maxima.length)

Een array is een object en kan worden aangemaakt voor alle Java typen, dus zowel primitieven als objecten. Omdat een array een object is, is het dus ook mogelijk om een array van arrays te gebruiken:

1: int[][] temperatuurPerUur = new int[365][24];

Hier wordt een array aangemaakt van 365 elementen die elk een array van 24 int elementen bevatten. Als een array is aangemaakt is het niet meer mogelijk om de array van grootte te laten veranderen.

Command Line Argumenten

Een programma dat geen invoer leest is over het algemeen niet zo nuttig. Een manier om een programma invoer te geven is het meegeven van zogenaamde command line argumenten. Andere manieren kan je vinden onder In- & uitvoer. Het volgende programma doet niets anders dan de argumenten die meegegeven zijn afdrukken:

1: public class Echo {
2:   public static void main(String[] args) {
3:     System.out.println("De waarde van de argumenten:");
4:     for (int i = 0; i < args.length; i++) {
5:       System.out.println(args[i]);
6:     }
7:   }
8: }

Sinds Java 5 valt deze code echter simpeler te herschrijven als volgt:

1: public class Echo {
2:   public static void main(String[] args) {
3:     System.out.println("De waarde van de argumenten:");
4:     for (String i:args) {                                 //i moet van het type String zijn want args[] is een Stringarray
5:       System.out.println(i);
6:     }
7:   }
8: }

Hierbij itereert de variabele i automatisch over elk element van de lijst "args" waarbij i achtereenvolgens de waarde aanneemt van het eerste, tweede, derde ... laatste argument van de lijst.

Deze pagina is vrijgegeven onder de GNU Free Documentation License (GFDL) en nog niet onder CC-BY-SA. Klik hier voor meer informatie.