Was ist Abstraktion in der OOP?

Question

Accepted Answer

**Abstraktion** bedeutet, zu zeigen *was* ein Objekt tut, während *wie* es das tut, verborgen bleibt. Sie interagieren mit einer einfachen, stabilen Schnittstelle und ignorieren die komplizierte Implementierung dahinter.

## Was versus wie

```python
from abc import ABC, abstractmethod

class PaymentGateway(ABC):          # the abstraction: "what"
    @abstractmethod
    def charge(self, amount): ...    # callers only need this contract

class StripeGateway(PaymentGateway): # one "how"
    def charge(self, amount):
        # talk to Stripe's API, handle tokens, retries...
        return f"charged {amount} via Stripe"

class PayPalGateway(PaymentGateway): # another "how"
    def charge(self, amount):
        return f"charged {amount} via PayPal"

def checkout(gateway: PaymentGateway, amount):
    return gateway.charge(amount)    # depends only on the abstraction
```

`checkout` weiß nie, ob es Stripe oder PayPal ist — es kommt auf die *Idee* des Bezahlens an, nicht auf die Details.

## Abstraktion versus Kapselung

Sie sind verwandt, aber unterschiedlich: **Kapselung** verbirgt den Zustand, um ihn zu schützen; **Abstraktion** verbirgt Komplexität, um die Schnittstelle zu vereinfachen. Kapselung ist *Schutz*; Abstraktion ist *was zu zeigen*.

## Fallstricke

Lecke Abstraktionen (wo Implementierungsdetails durchsickern) und zu frühe Abstraktionen (aufgebaut, bevor Sie das Problem verstehen) schaden beide. Abstrahieren Sie das, was sich wirklich ändert.

## Warum es wichtig ist

Abstraktion ist wie man Komplexität bändigt: Aufrufer denken über eine kleine Schnittstelle statt eines ganzen Subsystems nach.

Sie ermöglicht Implementierungen auszutauschen — das Hinzufügen eines neuen Zahlungsanbieters berührt eine Klasse, nicht jeden Aufrufer — was die Grundlage für flexibles, testierbares Design ist.