Was ist Abstraktion in der Programmierung?

Wenn du print("hi") schreibst, denkst du nicht darüber nach, wie diese Buchstaben auf den Bildschirm kommen. Unter dieser einen Zeile wandelt Python den Text in Bytes um und bittet das Betriebssystem, sie zu schreiben, das Betriebssystem reicht sie an dein Terminal weiter, und das Terminal zeichnet jeden Buchstaben mit einer Schriftart als Pixel. Jede Schicht gibt der Schicht darüber ein einfaches Versprechen und verbirgt, wie sie es hält. Dieses Verbergen ist Abstraktion, und jedes Programm sitzt auf vielen solchen Schichten.

Abstraktionsebenen

Jede Ebene ist aus der darunter gebaut und lässt sich ohne sie verstehen. Du kannst funktionierendes Python schreiben, ohne zu wissen, was ein Festplattenblock ist, und das Betriebssystem kann eine Datei speichern, ohne zu wissen, dass sie Python-Code enthält.

Wie Abstraktion im Code funktioniert

Programmierer bauen ihre eigenen Schichten auf zwei Hauptwegen.

Prozedurale Abstraktion ist eine Funktion. Ihr Name, ihre Parameter und ihr Rückgabewert sind die Schnittstelle; der Rumpf ist das verborgene Detail. Sobald average(scores) existiert, nutzt der Rest des Programms die Funktion, ohne nachzulesen, wie sie addiert und teilt.

Datenabstraktion definiert einen Typ über das, was man mit ihm tun kann, nicht darüber, wie er Dinge speichert. Eine Warteschlange heißt "hinten anfügen, vorne entnehmen". Wie die Elemente im Speicher liegen, ist eine private Entscheidung:

from collections import deque

class Queue:
    """First in, first out. Callers only see add() and next()."""
    def __init__(self):
        self._items = deque()     # swap this for a list and callers never notice
    def add(self, item):
        self._items.append(item)
    def next(self):
        return self._items.popleft()
    def __len__(self):
        return len(self._items)

orders = Queue()
for dish in ["soup", "pasta", "cake"]:
    orders.add(dish)
while len(orders):
    print("serving", orders.next())

serving soup
serving pasta
serving cake

Der Code ganz unten weiß nichts von deque. Ersetzt du es durch eine einfache Liste und pop(0), ist die Ausgabe identisch, nur bei langen Warteschlangen langsamer, weil das Entfernen des ersten Elements einer Liste jedes andere Element verschiebt. Die Schnittstelle blieb gleich, also musste sich außerhalb der Klasse nichts ändern.

Abstrakte Klassen und Interfaces

In der objektorientierten Programmierung bedeutet Abstraktion meist, festzulegen, was eine Familie von Klassen tun muss, und das Wie jeder Klasse selbst zu überlassen. In Python markiert das Modul abc eine Methode als abstrakt; eine Klasse mit einer nicht implementierten abstrakten Methode lässt sich nicht instanziieren:

from abc import ABC, abstractmethod

class Notifier(ABC):
    @abstractmethod
    def send(self, to, text):
        """Every notifier must say how it sends a message."""

class Email(Notifier):
    def send(self, to, text):
        print(f"email to {to}: {text}")

class SMS(Notifier):
    def send(self, to, text):
        print(f"sms to {to}: {text}")

def remind(notifier, user):
    notifier.send(user, "Your package arrives today")

remind(Email(), "ana@example.com")
remind(SMS(), "+15550100")
try:
    Notifier()
except TypeError:
    print("Notifier is abstract: create an Email or an SMS instead")

email to ana@example.com: Your package arrives today
sms to +15550100: Your package arrives today
Notifier is abstract: create an Email or an SMS instead

remind() hängt nur von der Abstraktion ab: von irgendetwas mit einer Methode send. Push-Benachrichtigungen hinzuzufügen heißt, eine neue Klasse zu schreiben, und remind() bleibt unberührt. Dieser letzte Schritt, ein Aufruf, der für verschiedene Klassen verschiedenen Code ausführt, ist Polymorphie: Die Abstraktion legt die gemeinsame Schnittstelle fest, die Polymorphie bringt sie zum Laufen.

Java hat dieselben Werkzeuge als Schlüsselwörter:

interface Notifier {
    void send(String to, String text);
}

class Email implements Notifier {
    public void send(String to, String text) { /* talk to the mail server */ }
}

new Notifier() zu schreiben ist ein Kompilierfehler, weil ein Interface keine Implementierung hat, die laufen könnte. Die Doku erklärt abstrakte Klassen und Interfaces in Java ausführlich.

Abstraktion und Kapselung im Vergleich

Die beiden Ideen tauchen so oft zusammen auf, dass man sie leicht verwechselt.

Die Abstraktion entscheidet, welche Operationen sichtbar sind; die Kapselung sorgt dafür, dass der Rest verborgen bleibt. Die Queue oben tut beides: add und next sind die Abstraktion, und der Unterstrich bei _items ist die Kapselung.

Undichte Abstraktionen und andere Fehler

Joel Spolsky formulierte 2002 das Gesetz der undichten Abstraktionen (Law of Leaky Abstractions): Jede nicht triviale Abstraktion lässt einen Teil des verborgenen Details durch. Gleitkommazahlen sind das klassische Leck. Sie sehen aus wie gewöhnliche Dezimalzahlen, bis die binäre Speicherung darunter durchscheint:

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

0.30000000000000004
False

Weder 0,1 noch 0,2 lassen sich in binären Bits exakt speichern, also liegt die Summe leicht daneben. Du kannst jahrelang mit Floats arbeiten, ohne darüber nachzudenken, aber nicht für immer, und deshalb hilft es, eine Ebene unter der eigenen zu kennen.

Zwei weitere Fehler sind häufig:

• Zu früh abstrahieren. Eine Klassenhierarchie für Fälle, die nie eintreten, ist zusätzlicher Code, den man lesen und ändern muss. Sandi Metz hat es so formuliert: "duplication is far cheaper than the wrong abstraction" (Duplikation ist weit billiger als die falsche Abstraktion).
• Abstraktion mit dem Schlüsselwort abstract verwechseln. Abstrakte Klassen sind ein Werkzeug. Jede gut benannte Funktion ist ebenfalls eine Abstraktion.

Wie es weitergeht

Lies Kapselung und Polymorphie, um das Bild der objektorientierten Programmierung zu vervollständigen. Die Seite zum Betriebssystem zeigt die größte Abstraktion, auf die sich deine Programme verlassen. Zum Üben baut der Python-Kurs von Anfang an Klassen und Funktionen, und der Java-Kurs behandelt abstrakte Klassen und Interfaces.