Was ist Kapselung?

Angenommen, eine Banking-App speichert den Kontostand jedes Kontos in einer einfachen Variablen. Jede Zeile irgendwo im Programm kann account.balance = -500 schreiben, und nichts hält sie auf. Taucht in der Produktion ein negativer Kontostand auf, musst du die ganze Codebasis nach jeder Stelle durchsuchen, die ihn angefasst hat. Kapselung löst das: Der Kontostand kann sich nur über wenige Methoden ändern, und diese Methoden setzen die Regeln durch, zum Beispiel, dass eine Abhebung nie den Kontostand übersteigen darf.

Wie Kapselung funktioniert

Kapselung verbindet zwei Ideen:

1. Bündeln. Die Daten (der Kontostand) und der Code, der mit ihnen arbeitet (einzahlen, abheben), stehen in derselben Klasse.
2. Verbergen. Anderer Code sieht nur die öffentliche Schnittstelle der Klasse. Die Daten dahinter sind intern, also können sie sich nur so ändern, wie die Klasse es erlaubt.

Die Regel, die die Klasse schützt, heißt Invariante: hier "der Kontostand ist nie negativ". Weil jede Änderung durch die Methoden der Klasse läuft, gilt die Invariante, egal was der Rest des Programms tut.

class BankAccount:
    def __init__(self):
        self._balance = 0  # internal: change it only through the methods

    @property
    def balance(self):     # read-only from outside
        return self._balance

    def deposit(self, amount):
        self._balance += amount

    def withdraw(self, amount):
        if amount > self._balance:
            raise ValueError("not enough money")
        self._balance -= amount

acct = BankAccount()
acct.deposit(100)
acct.withdraw(30)
print(acct.balance)
try:
    acct.withdraw(500)
except ValueError as err:
    print("refused:", err)

70
refused: not enough money

Code von außen kann acct.balance lesen, aber die Property hat keinen Setter, also wirft acct.balance = 1000 einen AttributeError. Stimmt der Kontostand irgendwann nicht, gibt es genau zwei Methoden, die du prüfen musst.

Kapselung in Python

Python hat kein Schlüsselwort private. Es verlässt sich auf Namenskonventionen, die jeder Python-Programmierer kennt:

• name: öffentlich, Teil der Schnittstelle.
• _name: intern. Nichts hindert dich daran, es zu lesen, aber der führende Unterstrich sagt "verlass dich nicht darauf".
• __name: Python benennt es innerhalb der Klasse um (Name Mangling), damit eine Unterklasse es nicht versehentlich überschreibt.
• @property: macht aus einer Methode etwas, das sich wie ein Attribut liest, sodass du später Prüfungen ergänzen kannst, ohne aufrufenden Code zu ändern.

class Counter:
    def __init__(self):
        self._count = 0      # one underscore: "internal, please don't touch"
        self.__secret = 42   # two underscores: the name gets mangled

c = Counter()
print(c._count)                   # still readable: it is only a convention
print(hasattr(c, "__secret"))     # the plain name does not exist
print(c._Counter__secret)         # Python renamed it to _Counter__secret

0
False
42

Name Mangling verhindert Versehen, keinen Zugriff: Der umbenannte Name funktioniert weiterhin. Python vertraut darauf, dass Programmierer den Unterstrich respektieren. In der Praxis verwendet der meiste Python-Code einen einzelnen Unterstrich plus @property und hebt doppelte Unterstriche für Klassen auf, von denen geerbt werden soll. Mehr zum Schreiben von Klassen steht in der Doku zu Python-Klassen.

Kapselung in Java, C++ und JavaScript

Andere Sprachen erzwingen das Verbergen. In Java kann ein private-Feld nur innerhalb seiner eigenen Klasse verwendet werden:

public class BankAccount {
    private int balance;  // hidden from every other class

    public int getBalance() { return balance; }

    public void withdraw(int amount) {
        if (amount > balance) throw new IllegalArgumentException("not enough money");
        balance -= amount;
    }
}

account.balance = 1000; in einer anderen Klasse kompiliert nicht: javac meldet balance has private access in BankAccount.

C++ macht Member einer class standardmäßig privat und Member eines struct öffentlich. Die privaten #-Felder von JavaScript, eingeführt mit ES2022, lassen sich von außerhalb der Klasse überhaupt nicht lesen. Die Doku behandelt jede Sprache: Zugriffsmodifikatoren in Java, Zugriffsspezifizierer in C++ und private Felder in JavaScript.

Warum Kapselung wichtig ist

• Regeln stehen an einer Stelle. Die Prüfung "keine Abhebung über den Kontostand hinaus" steht einmal in withdraw, statt vor jeder Abhebung im Programm.
• Das Innere lässt sich frei ändern. Beschließt du, Geld als ganze Cent statt als Float zu speichern, ändert sich nur die Klasse. Code, der deposit(100) aufruft, funktioniert weiter.
• Leichteres Debuggen. Ist ein Wert falsch, sind die Verdächtigen die wenigen Methoden, die ihn ändern dürfen, und nicht jede Zeile im Programm.
• Weniger zu lernen und zu testen. Eine Klasse mit drei öffentlichen Methoden lässt sich über genau diese drei Methoden verstehen und testen.

Kapselung funktioniert auch oberhalb von Klassen. Ein Modul, das zwei Funktionen anbietet und zehn Hilfsfunktionen intern hält, ist auf dieselbe Weise gekapselt, und ebenso ein Betriebssystem, das Programme Dateien nur über Systemaufrufe öffnen lässt.

Sie wird oft mit Abstraktion verwechselt. Die Abstraktion entscheidet, was die Schnittstelle anbietet; die Kapselung schützt die Daten dahinter. Die Seite zur Abstraktion hat einen vollständigen Vergleich nebeneinander. Zusammen mit Polymorphie und Vererbung bilden sie die vier Säulen der objektorientierten Programmierung.

Häufige Fehler

• Ein Getter und ein Setter für jedes Feld. Ein setBalance, das jede Zahl annimmt, schützt nichts. Biete die Operationen an, die das Objekt braucht (withdraw), statt rohen Zugriff auf jedes Feld.
• Interne Objekte zurückgeben. Eine Methode, die self._items zurückgibt, reicht dem Aufrufer die echte Liste, die er nun ändern kann. Gib stattdessen eine Kopie oder ein Tupel zurück.
• Privat mit Sicherheit verwechseln. Zugriffsmodifikatoren verhindern Fehler, keine Angriffe. Java-Code kann private Felder über Reflection lesen, und Python-Code kann _name direkt lesen. Passwörter und Schlüssel brauchen echten Schutz, etwa Hashing und Verschlüsselung.

Wie es weitergeht

Lies als Nächstes Abstraktion, wo der Unterschied zwischen beiden Ideen erklärt wird, und dann Polymorphie. Der Python-Kurs baut Klassen Schritt für Schritt auf, und der Java-Kurs zeigt Kapselung, die der Compiler durchsetzt.