Vad är abstraktion i OOP?

Question

Accepted Answer

**Abstraktion** betyder att exponera *vad* ett objekt gör samtidigt som man döljer *hur* det gör det. Du interagerar med ett enkelt, stabilt gränssnitt och ignorerar den komplicerade implementeringen bakom det.

## Vad kontra hur

```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 aldrig om det är Stripe eller PayPal — det beror på *idén* om att debitera, inte detaljerna.

## Abstraktion kontra inkapsling

De är relaterade men distinkta: **inkapsling** döljer tillstand för att skydda det; **abstraktion** döljer komplexitet för att förenkla gränssnittet. Inkapsling handlar om *skydd*; abstraktion handlar om *vad som ska visas*.

## Fallgrop

Läckande abstraktioner (där implementeringsdetaljer läcker igenom) och för tidiga abstraktioner (byggda innan du förstår problemet) skadar båda. Abstrahera det som verkligen varierar.

## Varför det spelar roll

Abstraktion är hur du tyglar komplexitet: anropare resonerar om ett litet gränssnitt i stället för ett helt undersystem.

Det möjliggör utbyte av implementeringar — att lägga till en ny betalningsleverantör påverkar en klass, inte varje anropare — vilket är grunden för flexibel, testbar design.