Programmeren in Java/Basis

Uit Wikibooks
Ga naar: navigatie, zoek


Programmeren in Java In ontwikkeling. Revisiedatum: onbekend

  1. Inleiding Redelijk ontwikkeld. Revisiedatum: 22 augustus 2008
  2. Basis Goed ontwikkeld. Revisiedatum: 24 november 2007
  3. In- & uitvoer In ontwikkeling. Revisiedatum: 24 november 2007
  4. Stringbewerkingen In ontwikkeling. Revisiedatum: 24 november 2007
  5. Arrays Nog vrijwel niets. Revisiedatum: 24 november 2007
  6. Collections Nog vrijwel niets. Revisiedatum: 24 november 2007
  7. Exceptions Redelijk ontwikkeld. Revisiedatum: 24 november 2007
  8. Generics Nog vrijwel niets. Revisiedatum: 24 november 2007
  9. Ingebouwde functies Nog vrijwel niets. Revisiedatum: 20 januari 2007
  10. Multithreading Nog vrijwel niets. Revisiedatum: 20 januari 2007
  11. GUI In ontwikkeling. Revisiedatum: 24 november 2007
  12. JSP: JavaServer Pages Redelijk ontwikkeld. Revisiedatum: 24 november 2007

Klassen

  1. Klassen Goed ontwikkeld. Revisiedatum: 24 november 2007
  2. Overerving In ontwikkeling. Revisiedatum: 20 januari 2007
  3. Geavanceerde klassen In ontwikkeling. Revisiedatum: 24 november 2007

Design Patterns

  1. Strategy Pattern Nog vrijwel niets. Revisiedatum: 26 december 2010

Appendices

  1. Appendix A: Installatie In ontwikkeling. Revisiedatum: 24 november 2007
  2. Appendix B: Javadoc In ontwikkeling. Revisiedatum: 24 november 2007


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

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.

Java-code: Hallo.java

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

Compileren[bewerken]

Wanneer je vanuit een commandolijn-omgeving (DOS-prompt, UNIX-shell, Windows: Start > Run > typ "cmd" ...)(In Windows 8 krijg je toegang tot de opdracht Uitvoeren door te drukken op de toets met het Windows-logo + R.) werkt, ga je nu naar de map waar het bestand Hallo.java staat. Daar typ je het volgende commando:

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.

Uitvoeren[bewerken]

Om de bytecode uit te voeren gebruik je het programma "java". Dit programma leest de bytecode in en voert deze uit:

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.

Bespreking[bewerken]

Ik herneem even de code voor het gemak:

Java-code: Hallo.java

 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. Meer over klassen vind je in het hoofdstuk Klassen.

Op regel 2 zie je de signatuur voor de main-methode. Dit is de instapmethode, je programma begint altijd met deze methode (later meer over methodes).

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. De tekst die je meegeeft moet tussen haakjes en tussen aanhalingstekens. In plaats van tekst kan je ook variabelen afdrukken. Daarvoor moet je de naam van de variabele die je wilt afdrukken tussen de haakjes zetten, zonder aanhalingstekens.

Regel 4 en 5 sluiten respectievelijk de main methode en de klasse Hallo terug af. Dit is verplicht. Tip: Het is een goede gewoonte om wanneer je het begin van bijvoorbeeld een methode schrijft ook onmiddellijk de afsluitende accolade te schrijven. Als je een IDE gebruikt, is dit echter niet nodig.

Primitieve variabelen[bewerken]

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:

Java-code: Hallo.java

 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:

Java-code: Fragment uit Hallo.java

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 ± tot ± float g = 89.567;
double reëel getal (dubbele precisie) 64 ± tot ± 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[bewerken]

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:

Soort Type Symbool Betekenis Voorbeeld Resultaat van het voorbeeld
Wiskundig Binair = Een waarde toekennen aan een variabele a = 5; De variabele a (eerder gedeclareerd) krijgt waarde 5
Wiskundig Binair + Waarden/Variabelen bij elkaar optellen b = a + 1; De variabele b krijgt de waarde van (a + 1), hier dus 6
Wiskundig Binair - Waarden/Variabelen van elkaar aftrekken c = b - a; c krijgt de waarde van het verschil tussen b en a, hier dus 1
Wiskundig Binair * Vermenigvuldigen d = c * 5; d krijgt de waarde van c vermenigvuldigd met 5, hier dus 5
Wiskundig Binair / Delen of e = d / 10; e krijgt de waarde van d gedeeld door 10, hier dus 0.5
Wiskundig Binair  % Geeft de rest van een deling tussen linker en rechterlid (werkt enkel met gehele getallen) f = d % 5; f krijgt de rest van de deling d / 5, hier dus 0
Logisch Binair | Logische OF (op bit niveau) g = 4 | 5; g krijgt het resultaat van 100 OF 101 (binair dus), g is dus 101 (wat overeenkomt met 5).
Logisch Binair & Logische EN (op bit niveau) h = 4 & 5; h krijgt het resultaat van 100 EN 101 (binair), h zal dus 100 (4) zijn.
Logisch Unair ~ Logische NOT (op bit niveau) byte i = ~1; i zal -2 zijn: NOT 0000 0001 = 1111 1110 wat volgens "two's complement" gelijk is aan -2.
Relationeel Binair || Booleaanse OF (werkt met boolean types) boolean j = false || true; j zal "true" zijn want 0 (false) OF 1 (true) geeft 1 (true)
Relationeel Binair && Booleaanse EN boolean k = j && false; k zal false zijn, ongeacht de waarde van j.
Relationeel Unair  ! Booleaanse NOT boolean l = !false; l is "not false", dus true.
Relationeel Binair == "Is linkerlid gelijk aan rechterlid?" boolean m = (5 == 6); m zal false zijn omdat 5 niet gelijk is aan zes, de == geeft een boolean als resultaat (true of false).
Relationeel Binair  != "Is linkerlid verschillend aan rechterlid?" boolean n = (5 != 6); n zal true zijn.
Relationeel Binair > "Is linkerlid groter dan rechterlid?" boolean o = (5 > 6); o zal false zijn.
Relationeel Binair >= "Is linkerlid groter dan of gelijk aan rechterlid?" boolean p = (4 >= 4); p zal true zijn.
Relationeel Binair < "Is linkerlid kleiner dan rechterlid?" boolean q = (5 < 6); q zal true zijn.
Relationeel Binair <= "Is linkerlid kleiner dan of gelijk aan rechterlid?" boolean r = (6 <= 5); r zal false zijn.

Bijkomende operatoren[bewerken]

Naast de bovenstaande operatoren zijn er nog enkele verkorte notaties voor veelgebruikte bewerkingen (eigenlijk samentrekkingen van meerdere bewerkingen):

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

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

Java-code: Codefragment om verkorte operatoren te illustreren:

 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:

Java-code: Codefragment om verkorte operatoren te illustreren:

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

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

Auto-increment operatoren[bewerken]

Als laatste heb je ook nog de auto-increment- en auto-decrementoperatoren. 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 (preincrementie) of na (postincrementie) de variabele staat.

Java-code: IncrementKort.java

 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 preincrementie (++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 postincrementie (a++) gebruikt, zal het resultaat van de bewerking de waarde van de variabele vóór de incrementie zijn, maar zal de variabele wel met 1 verhoogd/verlaagd worden. Je merkt ook dat pre- of postincrementie enkel van belang zijn als je het resultaat van de bewerking gebruikt. Als je echter gewoon de waarde van een variabele wilt verhogen of verlagen zijn beide incrementies gelijkwaardig.

Java-code: IncrementLang.java

 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 nog steeds leesbaar blijft.

Operatorprecedentie[bewerken]

In Java kan je operatoren en variabelen combineren in uitdrukkingen, net zoals men dit doet in wiskundig rekenwerk. Maar als je bijvoorbeeld de volgende code typt, wat is dan de waarde van de variabele resultaat?

Java-code: Precedentie.java

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

Om dit te weten te komen kan men gebruik maken van volgend schema.
Operatorprecedentie in Java.png
Operatoren op een hogere regel hebben een hogere precedentie dan de operatoren op lagere regels, zij zullen dus het eerst uitgevoerd worden. Operatoren op dezelfde regel hebben dezelfde precedentie, zij zullen gewoon van links naar rechts uitgevoerd worden volgens hoe ze in je code staan. Links en rechts associatief betekent dat de operatoren ofwel van links naar rechts ofwel van rechts naar links uitgevoerd worden. Haakjes worden van binnen naar buiten uitgevoerd, net zoals in de gewone volgorde van bewerkingen bij wiskunde. Je kan deze standaard operatorprecedentie dus "aanpassen" door gebruik te maken van haakjes. De waarde van de variabele resultaat is in bovenstaand stukje code trouwens 21.

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 zou krijgen. Hierover gaat de volgende sectie.

Conditioneel programmaverloop[bewerken]

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.

Java-code: AbsoluutVerschil.java

 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:

Java-code: Switch.java

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

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

De for-loop[bewerken]

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

Java-code: ForTest.java

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

In deze for lus staan tussen de haken 3 statements. Het eerste wordt voor de eerste iteratie van de lus uitgevoerd (meestal de initialisatie van een variabele i = 0), 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 (meestal auto-incrementie van de variabele die in het eerste statement gedeclareerd wordt).

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

De while-loop[bewerken]

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

Java-code: WhileTest.java

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

Bij het uitvoeren van deze programma's zie je onmiddellijk het verschil in resultaat tussen beide lussen. Beide lussen lopen door zolang i < 5 geldig is, maar aan het einde van de while-loop heeft i een hogere waarde dan aan het einde van de for-loop.

Controle over lussen[bewerken]

Zowel de for- als de while-loop hebben een boolean statement dat de uitvoer van de lus bepaalt. Het is echter ook mogelijk om de uitvoer van de lus binnen de lus zelf te bepalen. Hiervoor gebruikt men bij Java "break" en "continue".

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

Arrays[bewerken]

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

Java-code:

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:

Java-code:

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:

Java-code:

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:

Java-code:

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

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:

Java-code: Echo.java

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:

Java-code: Echo.java

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.


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


Informatie afkomstig van http://nl.wikibooks.org Wikibooks NL.
Wikibooks NL is onderdeel van de wikimediafoundation.