Hva er abstraksjon i OOP?

Question

Accepted Answer

**Abstraksjon** betyr å eksponere *hva* et objekt gjør mens du skjuler *hvordan* det gjør det. Du interagerer med et enkelt, stabilt grensesnitt og ignorerer den kompliserte implementeringen bak det.

## Hva vs. 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` vet aldri om det er Stripe eller PayPal — det avhenger av *idéen* om å ta betaling, ikke detaljene.

## Abstraksjon vs. innkapsling

De er relatert men forskjellige: **innkapsling** skjuler tilstand for å beskytte den; **abstraksjon** skjuler kompleksitet for å forenkle grensesnittet. Innkapsling handler om *beskyttelse*; abstraksjon handler om *hva som skal vises*.

## Fallgruber

Lekkende abstraksjoner (der implementeringsdetaljer siver gjennom) og for tidlig abstraksjon (bygd før du forstår problemet) skader begge. Abstraher det som virkelig varierer.

## Hvorfor det er viktig

Abstraksjon er hvordan du tøyler kompleksitet: kaller resonnerer om et lite grensesnitt i stedet for et helt delsystem.

Det gjør det mulig å bytte implementasjoner — å legge til en ny betalingsleverandør påvirker en klasse, ikke alle kallere — som er grunnlaget for fleksibel, testbar design.