Hoofdstuk 5 — Variabelen en Datatypen (bouwstenen van gegevens)

In dit hoofdstuk leer je welke soorten gegevens (datatypen) Java kent en hoe je er veilig mee werkt. We starten met primitieve typen (zoals int en double) en verkennen vervolgens referentietypen (zoals String en zelfgemaakte klassen). Je leert ook over typeconversie (casting), initialisatie, standaardwaarden, immutability van strings, en veelgemaakte valkuilen.

Wat ga je leren:

• Verschil tussen primitieve en referentietypen.
• Overzicht van primitieve typen: boolean, byte, short, int, long, float, double, char.
• Literalen (bijv. 123, 12.34, 'A', "tekst") inclusief underscores in numerieke literalen.
• Typeconversie: impliciet en expliciet (casting), en wat er gebeurt bij overloop (overflow).
• Werken met String (immutable), StringBuilder (mutable) en basishandelingen.
• Var (type-inferentie) sinds Java 10: wanneer wel en wanneer niet gebruiken.

Voorbeeld 1 — Primitieven declareren en initialiseren

public class PrimitievenDemo {
    public static void main(String[] args) {
        int leeftijd = 20;
        double prijs = 19.99;
        boolean actief = true;
        char initiaal = 'J';
        long populatie = 8_100_000_000L; // L suffix voor long
        float temperatuur = 21.5f;       // f suffix voor float
        System.out.println(leeftijd + ", " + prijs + ", " + actief + ", " + initiaal + ", " + populatie + ", " + temperatuur);
    }
}

Voorbeeld 2 — Standaardwaarden in velden (niet in lokale variabelen)

public class Standaardwaarden {
    static int standaardInt;      // 0
    static boolean standaardBool; // false
    static double standaardDouble;// 0.0
    static String standaardRef;   // null
    public static void main(String[] args) {
        int lokaal; // lokale variabelen MOET je initialiseren
        // System.out.println(lokaal); // compileerfout
        System.out.println(standaardInt + ", " + standaardBool + ", " + standaardDouble + ", " + standaardRef);
    }
}

Voorbeeld 3 — Casting en overflow

public class CastingOverflow {
    public static void main(String[] args) {
        int a = 130;
        byte b = (byte) a; // past niet in byte (-128..127) → overflow
        System.out.println("a = " + a + ", b = " + b); // b kan -126 zijn
        double x = 3.9;
        int y = (int) x;   // truncatie naar 3
        System.out.println("y = " + y);
    }
}

Voorbeeld 4 — Impliciete promotie bij rekenen

public class PromotieDemo {
    public static void main(String[] args) {
        byte b1 = 10, b2 = 20;
        int som = b1 + b2; // promotie naar int bij optelling
        long l = 1_000_000_000L;
        long product = l * 2; // let op type: int*int kan overflow geven
        System.out.println("som = " + som + ", product = " + product);
    }
}

Voorbeeld 5 — Strings zijn immutable

public class StringImmutability {
    public static void main(String[] args) {
        String s = "Java";
        String t = s.toUpperCase(); // maakt een nieuw String-object
        System.out.println(s); // "Java"
        System.out.println(t); // "JAVA"
    }
}

Voorbeeld 6 — StringBuilder voor efficiënte opbouw

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hallo").append(", ").append("wereld!");
        System.out.println(sb.toString());
    }
}

Voorbeeld 7 — Literalen en underscores

public class LiteralenDemo {
    public static void main(String[] args) {
        int miljoen = 1_000_000;     // underscores voor leesbaarheid
        double pi = 3.141_592_653_589;
        char euro = '\u20AC';        // Unicode literal
        System.out.println(miljoen + ", " + pi + ", " + euro);
    }
}

Voorbeeld 8 — var (type-inferentie) verstandig gebruiken

public class VarDemo {
    public static void main(String[] args) {
        var a = 10;        // a is int
        var b = 10.0;      // b is double
        var tekst = "Hallo"; // tekst is String
        // var x; // mag niet: moet direct worden geïnitialiseerd
        System.out.println(a + ", " + b + ", " + tekst);
    }
}

Voorbeeld 9 — Wrapper-klassen en autoboxing

public class WrappersDemo {
    public static void main(String[] args) {
        Integer i = 10; // autoboxing van int naar Integer
        int j = i;      // unboxing
        Boolean flag = Boolean.TRUE;
        System.out.println(i + j + (flag ? 1 : 0));
    }
}

Veelgemaakte fouten en tips:

• Vergeet suffixen niet: gebruik L voor long-literal en f voor float.
• Vermijd onnodige casts; ze kunnen informatie verliezen (truncatie/overflow).
• Wees bewust dat String immutable is; gebruik StringBuilder bij veel concatenaties in lussen.
• Lokale variabelen moeten vóór gebruik geïnitialiseerd worden.

Koppeling met oefeningen:

• Zie java-workbook/src/chapter_5.md voor opdrachten over types, casting en strings.
• Uitwerkingen in java-solutions/src/chapter_5.md en bijbehorende Java-bestanden.