Hvad er abstraktion i OOP?

Question

Accepted Answer

**Abstraktion** betyder at afsløre *hvad* et objekt gør, samtidig med at skjule *hvordan* det gør det. Du interagerer med en simpel, stabil grænseflade og ignorerer den rodede implementering bag ved.

## Hvad versus hvordan

```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` ved aldrig, om det er Stripe eller PayPal — det afhænger af *idéen* om opladning, ikke detaljerne.

## Abstraktion versus indkapsling

De er relaterede men forskellige: **indkapsling** skjuler tilstand for at beskytte den; **abstraktion** skjuler kompleksitet for at forenkle grænsefladen. Indkapsling handler om *beskyttelse*; abstraktion handler om *hvad der skal vises*.

## Faldgruber

Lækende abstraktioner (hvor implementeringsdetaljer siver igennem) og for tidlig abstraktion (bygget før du forstår problemet) skader begge. Abstrahér det, der virkelig varierer.

## Hvorfor det betyder noget

Abstraktion er hvordan du tæmmer kompleksitet: opkaldere tænker på en lille grænseflade i stedet for et helt subsystem.

Det muliggør at bytte implementeringer — at tilføje en ny betalingsudbyder påvirker en klasse, ikke hver opkalder — hvilket er grundlaget for fleksibel, testbar design.