Hoe begrijp je de betekenis van encapsulatie in programmeren?

Incapsulatie is een mechanisme dat het mogelijk maakt de interne implementatie van een object te verbergen en toegang tot zijn gegevens en gedrag alleen via een gedefinieerde interface te bieden.

Basisprincipes van encapsulatie:

• Gegevensverberg: Directe toegang tot de interne staat van het object wordt beperkt. Gegevens zijn alleen toegankelijk via de methoden van het object.
• Interface bieden: Interactie met het object gebeurt via een set openbare methoden die bepalen hoe het object gebruikt kan worden zonder de interne structuur te kennen.

Voordelen van encapsulatie:

• Modulariteit: Onderdelen van het systeem worden onafhankelijk en kunnen afzonderlijk worden ontwikkeld, getest en gewijzigd.
• Flexibiliteit: De interne implementatie van het object kan worden gewijzigd zonder invloed op de code die het gebruikt, zolang de interface behouden blijft.
• Gegevensbeveiliging: Voorkomt onjuiste wijziging van de toestand van het object van buitenaf.
• Code vereenvoudiging: Door de complexiteit van de implementatie te verbergen, maakt encapsulatie de code begrijpelijker en gemakkelijker te onderhouden.

Voorbeeld van encapsulatie in JavaScript:

class Counter {
  #count; // Privéveld, alleen toegankelijk binnen de klasse

  constructor(initialCount = 0) {
    this.#count = initialCount;
  }

  // Openbare methode om de teller te verhogen
  increment() {
    this.#count++;
    console.log('Huidige teller:', this.#count);
  }

  // Openbare methode om de huidige waarde van de teller te krijgen
  getCount() {
    return this.#count;
  }
}

const myCounter = new Counter(5);
myCounter.increment(); // Uitvoer: Huidige teller: 6
console.log(myCounter.getCount()); // Uitvoer: 6

// Poging tot directe toegang tot het privéveld zal een fout veroorzaken
// console.log(myCounter.#count);