Kapselung

9.1 Grundkonzepte

Kapselung ist ein grundlegendes Konzept der objektorientierten Programmierung (OOP), das es ermöglicht, die internen Details der Implementierung eines Objekts zu verbergen und den Zugang zu diesen Details durch strikt definierte Schnittstellen zu ermöglichen. Das hilft, die Sicherheit zu verbessern und die Verwaltung des Codes zu vereinfachen.

Vorteile der Kapselung:

1. Data Hiding: Kapselung ermöglicht es, die internen Details der Implementierung zu verbergen und den Zugang nur zu den notwendigen Methoden und Eigenschaften zu gewähren. Das verhindert inkorrekte Nutzung von Objekten und verbessert die Sicherheit des Codes.
2. Zugriffskontrolle: Kapselung erlaubt es, den Zugang zu Daten und Methoden zu kontrollieren und bietet die Möglichkeit, den internen Zustand eines Objekts nur über bestimmte Methoden zu ändern.
3. Wartbarkeit: Kapselung verbessert die Wartung des Codes, da Änderungen in der Implementierung die externe Schnittstelle der Klasse nicht beeinflussen. Das erlaubt Änderungen in der Implementierung ohne Änderungen am Code, der die Klasse verwendet.
4. Verbesserung der Testbarkeit: Kapselung erlaubt es, die interne Implementierung eines Objekts zu isolieren, was Modultests vereinfacht und die Wahrscheinlichkeit von Nebeneffekten verringert.

In JavaScript wird Kapselung durch Methoden und Eigenschaften erreicht und seit ES2022 sind auch private Felder und Methoden verfügbar.

9.2 Kapselung durch Closures

Vor der Einführung von privaten Feldern in ES2022 wurde Kapselung in JavaScript oft durch die Verwendung von Closures erreicht.

Beispiel:

• Die Variable count ist nur innerhalb der Funktion createCounter verfügbar und von außen nicht zugänglich
• Die Methoden increment, decrement und getCount können mit der privaten Variable count interagieren

    
      function createCounter() {
        let count = 0; // private Variable

        return {
          increment() {
            count++;
            console.log(count);
          },
          decrement() {
            count--;
            console.log(count);
          },
          getCount() {
            return count;
          }
        };
      }

      const counter = createCounter();
      counter.increment(); // 1
      counter.increment(); // 2
      console.log(counter.getCount()); // 2
      counter.decrement(); // 1
    
  

9.3 Private Felder in ES2022

In ES2022 wurden private Felder und Methoden eingeführt, die mit dem Symbol # deklariert werden. Private Felder und Methoden können nicht von außerhalb der Klasse zugegriffen oder verändert werden.

Beispiel:

• Private Felder #name und #age werden mit dem Symbol # deklariert
• Die Methoden getName, getAge, setName und setAge erlauben die Interaktion mit den privaten Feldern
• Der Versuch, von außerhalb der Klasse auf private Felder zuzugreifen, führt zu einem Fehler

    
      class Person {
        #name; // privates Feld
        #age; // privates Feld

        constructor(name, age) {
          this.#name = name;
          this.#age = age;
        }

        getName() {
          return this.#name;
        }

        getAge() {
          return this.#age;
        }

        setName(name) {
          this.#name = name;
        }

        setAge(age) {
          if (age > 0) {
            this.#age = age;
          }
        }
      }

      const person = new Person('Alice', 30);
      console.log(person.getName()); // "Alice"
      console.log(person.getAge()); // 30
      person.setName('Bob');
      person.setAge(25);
      console.log(person.getName()); // "Bob"
      console.log(person.getAge()); // 25
      
      console.log(person.#name); // Fehler: privates Feld nicht zugänglich
    
  

9.4 Private Methoden

Private Methoden können ebenfalls mit dem Symbol # deklariert werden und sind von außerhalb der Klasse nicht zugänglich.

Beispiel:

• Das private Feld #balance und die private Methode #logTransaction werden verwendet, um den Zustand des BankAccount Objekts zu verwalten
• Die private Methode #logTransaction wird innerhalb der öffentlichen Methoden deposit und withdraw aufgerufen, um Transaktionen zu protokollieren

    
      class BankAccount {
        #balance;

        constructor(initialBalance) {
          this.#balance = initialBalance;
        }

        deposit(amount) {
          if (amount > 0) {
            this.#balance += amount;
            this.#logTransaction('deposit', amount);
          }
        }

        withdraw(amount) {
          if (amount > 0 && amount <= this.#balance) {
            this.#balance -= amount;
            this.#logTransaction('withdraw', amount);
          }
        }

        getBalance() {
          return this.#balance;
        }

        #logTransaction(type, amount) {
          console.log(`Transaction: ${type} ${amount}`);
        }
      }

      const account = new BankAccount(1000);
      account.deposit(500); // "Transaction: deposit 500"
      console.log(account.getBalance()); // 1500
      account.withdraw(200); // "Transaction: withdraw 200"
      console.log(account.getBalance()); // 1300
      
      account.#logTransaction('test', 100); // Fehler: private Methode nicht zugänglich