Toegang beperken met Access Modifiers¶

Doel¶

Je leert waarom het handig is om te bepalen wie toegang heeft tot welke data binnen je objecten. Access modifiers (zoals public en private) helpen om je code stabieler en beter onderhoudbaar te maken.

1. Het probleem: alles is openbaar¶

Stel, je hebt een simpele bal die beweegt:

class Ball {
  constructor(x, y, speed) {
    this.x = x;
    this.y = y;
    this.speed = speed;
  }
  move() {
    this.x += this.speed;
  }
  show() {
    circle(this.x, this.y, 20);
  }
}

let oneBall;

function setup() {
  createCanvas(400, 200);
  oneBall = new Ball(50, 100, 2);
}

function draw() {
  background(220);
  oneBall.move();
  oneBall.show();
}

Dit werkt prima, maar alles in de class is openbaar. Dat betekent dat iemand anders in de code dit kan doen:

oneBall.x = 'Hallo'; // ❌ Oeps — nu is x geen getal meer
oneBall.speed = -999; // ❌ Bal verdwijnt uit beeld

Als je programma groeit, wordt het onduidelijk wie de waarden aanpast. Een kleine fout kan onverwachte gevolgen hebben.

2. Het idee van access modifiers¶

We willen voorkomen dat andere delen van het programma direct met de interne data van Ball rommelen. In JavaScript doe je dat met een privé-veld: je zet er een # voor.

class Ball {
  #x;
  #y;
  #speed;

  constructor(x, y, speed) {
    this.#x = x;
    this.#y = y;
    this.#speed = speed;
  }

  move() {
    this.#x += this.#speed;
  }

  show() {
    circle(this.#x, this.#y, 20);
  }
}

Nu kun je buiten de class niet meer rechtstreeks bij #x, #y of #speed. De volgende code veroorzaakt een fout:

oneBall.#x = 500; // ❌ SyntaxError: Private field '#x' must be declared in an enclosing class

3. Gecontroleerde toegang via getters en setters¶

Soms wil je data wel kunnen lezen of wijzigen, maar op een gecontroleerde manier. Dan gebruik je getters en setters.

class Ball {
  #x;
  #y;
  #speed;

  constructor(x, y, speed) {
    this.#x = x;
    this.#y = y;
    this.#speed = speed;
  }

  get x() { return this.#x; }
  set speed(v) {
    if (v > 0 && v < 10) this.#speed = v;
  }

  move() {
    this.#x += this.#speed;
  }
  show() {
    circle(this.#x, this.#y, 20);
  }
}

Nu kunnen andere delen van je code de positie lezen maar de snelheid alleen wijzigen binnen veilige grenzen.

oneBall.speed = 50; // te hoog, wordt genegeerd
oneBall.speed = 3; // toegestaan
console.log(oneBall.x); // mag, via getter

Mini-opdracht

Kopieer de oorspronkelijke (onbeschermde) versie van de Ball-class. Voeg in draw() extra code toe die soms willekeurig de waarden verandert:

if (frameCount % 60 === 0) {
    oneBall.x = random(400);
    oneBall.speed = random(-10, 10);
}

Je zult merken dat de bal soms verdwijnt of vreemd beweegt.

Stap 2: Gebruik de versie met #private velden en zie dat dit niet meer kan. De bal blijft zich voorspelbaar gedragen.

Reflectievraag

Wat zegt dit over de betrouwbaarheid en onderhoudbaarheid van je code als meerdere mensen eraan werken?

5. Wanneer access modifiers handig zijn¶

Bij grotere projecten waarin meerdere classes samenwerken.
Wanneer je data wilt beschermen tegen foutief gebruik.
Als je duidelijk wilt maken welke delen van de code publiek zijn en welke intern.

Voorbeeld: combineren met andere classes

Een programma met meerdere objecten wordt al snel onduidelijk als alles overal toegankelijk is.

class Game {
    constructor() {
        this.ball = new Ball(50, 100, 2);
    }
    update() {
        this.ball.move();
    }
    draw() {
        background(220);
        this.ball.show();
    }
}

Met private velden in Ball weet de Game-class precies wat ze mag doen (alleen via move() en show()), en niet hoe Ball intern werkt. Dat maakt het eenvoudiger om Ball later aan te passen zonder dat Game moet worden herschreven.

7. Reflectie¶

Access modifiers helpen om:

de interne logica van je objecten te beschermen,
je code onderhoudbaar te houden,
en voorspelbaar gedrag te garanderen.

Je leert hierdoor beter nadenken over wie verantwoordelijk is voor wat in je programma.

Begrippen¶

Access modifier: bepaalt wie toegang heeft tot data of functies binnen een class.
Private field (#): alleen toegankelijk binnen de class zelf.
Public field: overal toegankelijk.
Getter/Setter: functies die gecontroleerde toegang geven tot private data.
Encapsulatie: het principe dat data en gedrag binnen één logische eenheid horen, met duidelijke grenzen.