Hoofdstuk 4 — Basis Syntax (regels, vormen en voorbeelden)
In dit hoofdstuk leer je de schrijfregels van Java: hoe je geldige uitspraken (statements) maakt, hoe blokken met {} werken, waar je puntkomma’s plaatst, hoe je namen (identifiers) kiest, en welke trefwoorden (keywords) gereserveerd zijn. Omdat we ons richten op absolute beginners, laten we elk concept zien met duidelijke, kleine voorbeelden. Aan het eind herken je typische syntaxfouten direct en kun je ze snel herstellen.
Kernideeën die je gaat zien:
- Java is hoofdlettergevoelig:
Systemis iets anders dansystem. - Elke statement eindigt met
;(behalve blok- en structurele regels zoalsif (...) { ... }). - Blokken code staan tussen
{en}en bepalen de “scope” (zichtbaarheid) van variabelen. - Namen van klassen beginnen normaal gesproken met een hoofdletter (PascalCase), methoden/variabelen met een kleine letter (camelCase).
- Spaties en nieuwe regels maken de code leesbaar, maar ze veranderen (bijna) nooit de betekenis.
- Java kent gereserveerde woorden (zoals
class,if,for,switch) die je niet als variabelenaam mag gebruiken.
Laten we stap voor stap de belangrijkste stukken syntax bekijken.
Voorbeeld 1 — De vorm van een klasse en de main‑methode
Introductie: We bekijken de basisvorm van een Java‑klasse en waar de main‑methode staat.
public class VormDemo {
public static void main(String[] args) {
System.out.println("Hallo uit VormDemo");
}
}
Regels: de bestandsnaam moet VormDemo.java zijn, puntkomma’s aan het einde van statements, en de main‑methode heeft exact de signatuur public static void main(String[] args).
Voorbeeld 2 — Witte ruimte: spaties en nieuwe regels Introductie: Extra spaties en nieuwe regels beïnvloeden de betekenis nauwelijks; ze helpen vooral leesbaarheid.
public class Witruimte {
public static void main(String[] args) {
System.out.println("Dit" + " werkt");
System.out.println("Ook dit werkt");
System.out.println(
"En zelfs met nieuwe regels tussen argumenten"
);
}
}
Spaties en nieuwe regels zijn meestal voor menselijk leesgemak; de compiler negeert extra witruimte.
Voorbeeld 3 — Puntkomma’s en blokken
Introductie: Statements eindigen met ; en blokken {} bepalen scope en levensduur van variabelen.
public class PuntkommaEnBlokken {
public static void main(String[] args) {
int a = 3; int b = 4; // twee statements op één regel (kan, maar minder leesbaar)
{
int c = a + b; // c is alleen binnen dit blok zichtbaar
System.out.println("c = " + c);
}
// System.out.println(c); // compileerfout: c bestaat hier niet meer
}
}
Een statement eindigt op ;. Een blok { ... } kan variabelen afschermen voor de buitenwereld.
Voorbeeld 4 — Namen (identifiers) en conventies Introductie: Goede naamgeving maakt code leesbaar; let op conventies voor klassen en variabelen.
public class NaamConventies {
static int MAXIMUM_AANTAL = 10; // constante: vaak UPPER_SNAKE_CASE
static int minimumAantal = 1; // variabele/methode: camelCase
public static void main(String[] args) {
int aantalStudenten = 3;
System.out.println("aantalStudenten = " + aantalStudenten);
}
}
Je mag letters, cijfers, _ en $ gebruiken, maar geen spatie of met een cijfer beginnen. Gebruik betekenisvolle namen.
Voorbeeld 5 — Keywords (gereserveerde woorden)
public class KeywordsDemo {
public static void main(String[] args) {
// int class = 5; // mag niet: "class" is gereserveerd
int klasse = 5; // dit mag wel (maar gebruik liever echte betekenisvolle namen)
System.out.println(klasse);
}
}
Bekende keywords: class, if, else, for, while, switch, case, break, continue, return, try, catch, finally, new, public, private, protected, static, void, enz.
Voorbeeld 6 — Expressies en operatoren
public class ExpressiesDemo {
public static void main(String[] args) {
int a = 5 + 2 * 3; // vermenigvuldiging eerst (prioriteit)
int b = (5 + 2) * 3; // haakjes veranderen de volgorde
boolean groot = a > b; // vergelijking levert boolean op
System.out.println("a = " + a + ", b = " + b + ", groot = " + groot);
}
}
Je combineert waarden en operatoren tot expressies die een resultaat opleveren.
Voorbeeld 7 — If/else‑blokken en scopes
public class IfElseBlokken {
public static void main(String[] args) {
int score = 55;
if (score >= 60) {
String bericht = "Geslaagd";
System.out.println(bericht);
} else {
String bericht = "Gezakt"; // ander bericht in een ander blok
System.out.println(bericht);
}
// buiten de blokken bestaan deze lokale variabelen niet meer
}
}
Variabelen die in een blok gedeclareerd zijn, leven niet buiten dat blok.
Voorbeeld 8 — Switch‑expressie (Java 21) en pijl‑syntaxis
public class SwitchPijlen {
public static void main(String[] args) {
int dag = 3;
String naam = switch (dag) {
case 1 -> "Maandag";
case 2 -> "Dinsdag";
case 3 -> "Woensdag";
case 4 -> "Donderdag";
case 5 -> "Vrijdag";
case 6, 7 -> "Weekend";
default -> "Onbekend";
};
System.out.println(naam);
}
}
In moderne Java kun je switch als expressie gebruiken die direct een waarde oplevert.
Voorbeeld 9 — For/while/do‑while vormen
public class LussenVormen {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
System.out.println("for: " + i);
}
int j = 0;
while (j < 3) {
System.out.println("while: " + j);
j++;
}
int k = 0;
do {
System.out.println("do-while: " + k);
k++;
} while (k < 3);
}
}
De vorm (plaats van initialisatie/voorwaarden) bepaalt hoe de lus verloopt.
Voorbeeld 10 — Methoden: definitie en aanroep
public class MethodenVorm {
static int som(int a, int b) {
return a + b; // return beëindigt de methode en levert een waarde
}
public static void main(String[] args) {
int uitkomst = som(2, 3);
System.out.println("som = " + uitkomst);
}
}
Methodesignature: naam, parameterlijst met types, en het returntype. void betekent: geen waarde terug.
Voorbeeld 11 — String‑literal, char‑literal en escaping
public class TekstLiterals {
public static void main(String[] args) {
String s = "Hallo\nwereld"; // \n is newline
char c = '\''; // enkel aanhalingsteken als char
System.out.println(s);
System.out.println("char: " + c);
}
}
Let op het verschil tussen "..." voor String en '...' voor een char.
Voorbeeld 12 — Commentaar en JavaDoc
public class CommentaarVorm {
/**
* Tel twee getallen bij elkaar op.
*/
static int telOp(int a, int b) {
return a + b; // inline opmerking
}
public static void main(String[] args) {
// Een enkele regel commentaar
System.out.println(telOp(1, 2));
/*
Blokcommentaar voor langere toelichting.
*/
}
}
Gebruik commentaar spaarzaam om intentie te verduidelijken.
Veelgemaakte syntaxfouten en hoe je ze oplost
- Vergeten
;aan het einde van een statement → voeg de puntkomma toe waar de IDE de fout markeert. - Accolades niet in balans (
{zonder}) → laat de IDE automatisch herschikken of voeg de ontbrekende bracket toe. - Naam/bestand klopt niet met
public class→ hernoem het bestand of de klasse zodat ze overeenkomen. - Hoofdletterfout (
systemi.p.v.System) → Java is case‑sensitive; corrigeer de hoofdletters. - Keyword als variabelenaam → kies een andere, geldige naam.
Stijlrichtlijnen die je nu al kunt volgen
- Consistente inspringing (2 of 4 spaties; kies één en blijf daarbij).
- Spaties rond operatoren:
a + bleest prettiger dana+b. - Maximaal één publieksklasse per
.java‑bestand en die moet de bestandsnaam bepalen.
Koppeling met oefeningen
- Zie
java-workbook/src/chapter_4.mdvoor opdrachten over blokken, statements, switch‑expressie en lussen. - Zie
java-solutions/src/chapter_4.mdvoor voorbeeldoplossingen.
Samenvatting
Je hebt de basisvormen van Java‑syntax gezien: statements met puntkomma’s, blokken met {} en scopes, namen en conventies, operators en controlestromen, methoden, en string/char‑literals. Met deze “taalregels” kun je alle komende hoofdstukken beter begrijpen en fouten sneller oplossen.