Wat is abstractie in OOP?

Question

Accepted Answer

**Abstractie** betekent dat je laat zien *wat* een object doet terwijl je verborgen houdt *hoe* het dat doet. Je werkt met een eenvoudige, stabiele interface en negeer de ingewikkelde implementatie erachter.

## Wat versus hoe

```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` weet nooit of het Stripe of PayPal is — het vertrouwt op het *idee* van betalen, niet op de details.

## Abstractie versus inkapseling

Ze hangen samen maar zijn onderscheiden: **inkapseling** verbergt toestand om deze te beschermen; **abstractie** verbergt complexiteit om de interface te vereenvoudigen. Inkapseling gaat om *bescherming*; abstractie gaat om *wat te tonen*.

## Valkuil

Lekende abstracties (waarbij implementatiedetails naar buiten komen) en voortijdige abstracties (gemaakt voordat je het probleem begrijpt) zijn beide schadelijk. Abstraheer alleen wat echt varieert.

## Waarom het belangrijk is

Abstractie is hoe je complexiteit tempert: bellers redeneren over een kleine interface in plaats van over een volledig subsysteem.

Het maakt het mogelijk implementaties uit te wisselen — het toevoegen van een nieuwe betaalprovider raakt één klasse aan, niet alle bellers — wat de basis is van flexibel, testbaar design.