Hoofdstuk 6 — Operators en Expressies (rekenen en logica in Java)

In dit hoofdstuk duiken we in operatoren: symbolen waarmee je rekent, vergelijkt en logische beslissingen maakt. Je ziet ook toekenningsoperatoren, samengestelde toekenning (+=, -=), incrementeer/decrementeer (++, --), en de volgorde van evaluatie en prioriteiten.

Categorieën operatoren die je leert:

Reken: + - * / %
Vergelijking: == != < > <= >=
Logisch: && || ! (kortsluitend AND/OR)
Toekenning: =, samengestelde: +=, -=, *=, /=, %=
Incrementeer/decrementeer: ++, -- (prefix en postfix)
Bitwise (kort): & | ^ ~ << >> >>> (voor gevorderden, hier kort aangestipt)
Ternary: voorwaarde ? waarde1 : waarde2

Voorbeeld 1 — Basisrekenen Introductie: We oefenen de rekenoperatoren en laten zien wat elke bewerking oplevert.

public class RekenDemo {
    public static void main(String[] args) {
        int a = 5, b = 2;
        System.out.println("som = " + (a + b));
        System.out.println("verschil = " + (a - b));
        System.out.println("product = " + (a * b));
        System.out.println("deling (geheel) = " + (a / b));
        System.out.println("modulo (rest) = " + (a % b));
    }
}

Toelichting: Let op het verschil tussen gehele deling en modulo; modulo geeft de restwaarde van een deling.

Voorbeeld 2 — Deling met double Introductie: We laten zien dat deling met doubles een kommagetal oplevert.

public class DoubleDeling {
    public static void main(String[] args) {
        double x = 5, y = 2;
        System.out.println(x / y); // 2.5
    }
}

Toelichting: Door doubles te gebruiken krijg je 2.5 in plaats van een gehele uitkomst.

Voorbeeld 3 — Vergelijkingen en boolean Introductie: We vergelijken waarden en laten zien dat het resultaat een boolean is.

public class VergelijkDemo {
    public static void main(String[] args) {
        int a = 5, b = 2;
        System.out.println(a > b);   // true
        System.out.println(a == b);  // false
        System.out.println(a != b);  // true
    }
}

Toelichting: Vergelijkingsoperatoren leveren true/false; gebruik ze in beslissingen.

Voorbeeld 4 — Logische operatoren met kortsluiting Introductie: We demonstreren kortsluiting: de rechter operand wordt soms niet geëvalueerd.

public class LogischDemo {
    static boolean test(String naam, boolean resultaat) {
        System.out.println("test(" + naam + ")");
        return resultaat;
    }
    public static void main(String[] args) {
        boolean z = test("A", false) && test("B", true); // B wordt niet meer aangeroepen
        boolean w = test("C", true) || test("D", false); // D wordt niet meer aangeroepen
        System.out.println(z);
        System.out.println(w);
    }
}

Toelichting: Bij && stopt evaluatie zodra links al false is; bij || zodra links true is.

Voorbeeld 5 — Samengestelde toekenning en ++/-- Introductie: We tonen het effect van samengestelde toekenning en het verschil tussen prefix en postfix.

public class ToekenningDemo {
    public static void main(String[] args) {
        int x = 10;
        x += 5; // 15
        x *= 2; // 30
        int y = 3;
        System.out.println(++y); // prefix: verhoog, dan gebruik (4)
        System.out.println(y++); // postfix: gebruik, dan verhoog (4)
        System.out.println(y);   // nu 5
    }
}

Toelichting: ++y verhoogt vóór gebruik; y++ verhoogt na gebruik. Samengestelde toekenning past de waarde direct aan.

Voorbeeld 6 — Prioriteit en haakjes Introductie: Operatorprioriteit bepaalt volgorde; haakjes maken de intentie expliciet.

public class PrioriteitDemo {
    public static void main(String[] args) {
        int uitkomst = 2 + 3 * 4;     // 14
        int metHaakjes = (2 + 3) * 4; // 20
        System.out.println(uitkomst + ", " + metHaakjes);
    }
}

Toelichting: Zonder haakjes kan de uitkomst verrassen; zet haakjes voor duidelijkheid.

Voorbeeld 7 — Ternary operator Introductie: De voorwaardelijke operator kiest tussen twee waarden op basis van een conditie.

public class TernaryDemo {
    public static void main(String[] args) {
        int score = 62;
        String resultaat = score >= 60 ? "Geslaagd" : "Gezakt";
        System.out.println(resultaat);
    }
}

Toelichting: Handig voor compacte toekenningen of inline keuzes (bijv. in prints).

Voorbeeld 8 — Valstrikken met == en Strings Introductie: == vergelijkt referenties; voor inhoudsvergelijking gebruik je equals.

public class StringVergelijking {
    public static void main(String[] args) {
        String a = "Java";
        String b = new String("Java");
        System.out.println(a == b);        // false: vergelijkt referenties
        System.out.println(a.equals(b));   // true: vergelijkt inhoud
    }
}

Toelichting: Gebruik equals voor String-inhoud; == kan onverwacht false geven bij verschillende objecten.

Voorbeeld 9 — Bitwise (korte demo) Introductie: We tonen basis bitbewerkingen en verschuivingen op binaire waarden.

public class BitwiseDemo {
    public static void main(String[] args) {
        int m = 0b0011; // 3
        int n = 0b0101; // 5
        System.out.println(m & n); // 1
        System.out.println(m | n); // 7
        System.out.println(m ^ n); // 6
        System.out.println(n << 1); // 10
    }
}

Toelichting: &, |, ^ werken op bits; << verschuift links (maal 2), >> arithmetic shift, >>> logical shift.

Veelgemaakte fouten en tips:

Gebruik haakjes om de intentie duidelijk te maken, zeker bij gemengde operatoren.
Onthoud: && en || zijn kortsluitend (rechts wordt niet geëvalueerd als links al voldoende is).
Vergelijk Strings met equals, niet met ==.

Koppeling met oefeningen:

Zie java-workbook/src/chapter_6.md voor opdrachten over operatoren en expressies.
Uitwerkingen in java-solutions/src/chapter_6.md.

Keyboard shortcuts

Java Basis

Hoofdstuk 6 — Operators en Expressies (rekenen en logica in Java)