Programmeren in Java/Basis

Uit Wikibooks

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

[bewerken] Hallo wereld

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

Sla onderstaande code op (zonder de regelnummering!) in een bestand met de naam Hallo.java (let op de hoofdletters!)

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

[bewerken] Compileren

Wanneer je vanuit een commandolijn-omgeving (DOS prompt, UNIX shell, Windows: Start > Run > typ "cmd", ...) werkt, ga je nu naar de map waar het bestand Hallo.java staat. Daar typ je het volgende commando:

C:\java> javac Hallo.java

Dit zou normaal geen fouten mogen geven (als je compiler goed geïnstalleerd werd). In de map zou nu een bestand met de naam Hallo.class moeten staan. Dit bestand is de bytecode van ons "Hallo Wereld"-programma. "javac" is de java-compiler.

Om de bytecode uit te voeren gebruik je het programma "java". Dat de bytecode leest en uitvoert:

C:\java> java Hallo

De .class extensie laat je dus weg. Dit zou als resultaat "Hallo wereld!" in de console moeten afdrukken.

Indien je een IDE of iets dergelijks gebruikt en je slechts heel even een schermpje ziet voorbijflitsen, start je toch best via een command line shell of zoek je naar instellingen om dit venster open te houden.

[bewerken] Bespreking

Ik herneem even de code voor het gemak:

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

Op regel 1 maken we een nieuwe klasse aan. De public duidt erop dat deze code in het bestand moet zitten met dezelfde naam als de klasse, gevolgd door .java. In dit geval dus Hallo.java.

Op regel 2 zie je de signatuur voor de main methode. Dit is de instapmethode, je programma begint hier altijd.

Op regel 3 roepen we een methode op uit de Java API. Namelijk de methode println. Deze drukt de meegegeven tekst af in de console.

Regel 4 en 5 sluiten respectievelijk de main methode en de Hallo klasse terug af!

Tip: Het is een goede gewoonte om wanneer je het begin van bijvoorbeeld een methode schrijft ook onmiddelijk de afsluitende accolade te schrijven.

[bewerken] 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 naam a, b en c. Dit doen we met het sleutelwoord int, wat staat voor integer. Dit sleutelwoord bepaalt welk soort veranderlijke 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.

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 verder).

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. Elk voor hun eigen soort waarde:

Alle primitieve variabelen in java:

Variabelen verschillen onderling van formaat: Zo zijn er variabelen voor letters (ASCII-karakters), voor gehele getallen (bvb. int), voor kommagetallen, ...

Ze verschillen daarbij ook nog in die 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 wat 64 bits groot is. Wanneer je grote getallen wilt opslaan, kun je bijvoorbeeld liever een variabele van het long-type gebruiken dan van short. Je denkt hier best altijd eerst even over na, zodat je niet overbodige ruimte inneemt (ook al is deze maar enkele bytes).

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

[bewerken] 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.

We zijn er al drie 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:

Naast bovenstaande munitie zijn er nog enkele verkorte notaties voor veel gebruikte bewerkingen:

+=, -=, *=, /=, %= en |=, &=

Allemaal worden zij op dezelfde manier gebruikt; "x += y" betekent "x = x + y". Concreet werkt dit als volgt:

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

Dit codefragment zal 10 als uitvoer hebben. Bovenstaand stukje code kan voluit zo geschreven worden:

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

Natuurlijk moet het linkerlid een variabele zijn, die reeds een geinitialiseerde waarde heeft.

Als laatste heb je ook nog de prefix en postfix operatoren. Dit zijn operatoren die je kan gebruiken om een variabele met 1 te verhogen of te verlagen. Ze zien er zo uit: ++ en --. Je kan ze voor of na een variabele zetten (zonder spatie gescheiden) om deze variabele te bewerken (Bvb. "i++;" zal de variabele i met 1 verhogen, "j--;" zal j met 1 verlagen). Bemerk het verschil in gedrag wanneer de operator voor (prefix) of na (postfix) de variabele staat.

 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:}

Bij prefix (++a) wordt de variabele eerst met 1 verhoogd/verlaagd en de bewerking heeft als resultaat de nieuwe waarde van de variabele waarop de bewerking werd uitgevoerd. Wanneer je postfix (a++) gebruikt, zal het resultaat van de bewerking de waarde van de variabele vóór de bewerking zijn, maar zal de variabele wel met 1 verhoogd/verlaagd worden. Je merkt ook dat prefix of postfix enkel van belang zijn als je het resultaat van de bewerking gebruikt, als je gewoon de waarde van een variabele wil verhogen zijn beide systemen gelijkwaardig.

 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:}

Meestal is het gewenst niet elke bewerking op een aparte lijn te doen. Een bewerking heeft altijd een resultaat en dat resultaat kan gebruikt worden in een andere bewerking: (a = 2 + 3) kan gebruikt worden als volgt: b = (a = 2 + 3). Zo kan je vlotjes ingewikkelde bewerkingen op één regel plaatsen, maar let erop dat je code altijd leesbaar blijft.

Nu we alles weten om met variabelen te kunnen werken en we uitvoer naar de gebruiker kunnen sturen, kunnen we bijna echt zinvolle programma's maken, maar het zou handig zijn als ons programma afhankelijk van bepaalde factoren een ander verloop krijgt. Hierover gaat de volgende sectie.

[bewerken] Conditioneel programmaverloop

Computerprogramma's zijn weinig zinvol als ze altijd hetzelfde zijn. 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.

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 de if waar evalueert zal hij de volledige blok code 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 gevraag wordt. Een else statement komt altijd onmiddelijk na een if. Tenzij je gebruik maakt van "else if" op de volgende manier:

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

In de geest van een praktische aanpak geef ik een code voorbeeldje. 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 dat omgekeerd gebeuren. Dat zien we gebeuren op regel 8 en 9.

Op regel 8 zien we ook dat de sluitende accolade van het if statement staat als de else statement. Dit is een kwestie van stijl, je kan de else natuurlijk 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 codeinstructie staat (1 codeinstructie is van het begin van een instructie tot aan de eerste ;) kunnen we de accolades weglaten omdat we geen groep codeinstructies moeten uitvoeren. Maar dat is wederom een kwestie van stijl, om te beginnen laat je best voor alle duidelijkheid de accolades staan.

Naast de if else sequentie 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 de waarden uit.

Op regel 4 geven we die variabele mee aan de switch statement, we openen ook een code block.

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 gaat dus uit de switch. Dit is belangrijk want als de 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 enkel op komen dat knop 2 is ingedrukt. Doe dat 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.

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.

Het is afwegen of je best if of switch gebruikt van geval tot geval.

[bewerken] Lussen

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 iterators. 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).

[bewerken] De for lus

Met de for lus kun je een gecontroleerde herhaling laten plaats vinden.

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

In deze for lus staan tussen de haken 3 statements. Het eerste wordt voor de eerste iteratie van de lus uitgevoerd, het tweede is de conditie waaraan voldaan moet worden om een volgende iteratie te laten gebeuren (oftewel: true = verdergaan, false = stoppen), en het derde statement wordt na iedere iteratie uitgevoerd.

In dit geval: Het eerste statement initialiseert de variabele a en zet deze op 0, het tweede controleert of a nog kleiner is dan 5, en het derde zorgt ervoor dat a na iedere iteratie van de lus met 1 verhoogd wordt.

[bewerken] De while loop

Een variatie op de for lus, is de while lus. Deze lus bevat maar 1 boolean statement. Zolang deze true is, wordt de lus uitgevoerd.

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

Bij het uitvoeren van deze programma's zie je gelijk het verschil in resultaat. Beide lussen lopen door zolang a < dan 5, maar aan het einde van de while loop heeft a een hogere waarde dan aan het einde van de for loop.

[bewerken] Controle over lussen

Zowel de for als de while loop hebben een boolean statement wat de uitvoer van de lus bepaald. Het is echter ook mogelijk om de uitvoer van de lus binnen de lus zelf te bepalen. Hiervoor zijn break en continue keywords.

Break zorgt ervoor dat de lus meteen verlaten wordt ("uit de lus breken") Continue zorgt ervoor dat een nieuwe iteratie van de lus begint.

[bewerken] 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 aray 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.

[bewerken] 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. 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: }

Deze pagina is vrijgegeven onder de GNU Free Documentation License (GFDL) en nog niet onder CC-BY-SA. Klik hier voor meer informatie. Wilt u deze tekst gebruiken onder de Creative Commons CC-BY-SA licentie? Klik dan hier om te kijken van welke gebruikers u nog toestemming nodig heeft.