Che cosa è l'astrazione nella OOP?

Question

Accepted Answer

**L'astrazione** significa esporre *cosa* fa un oggetto mentre si nasconde *come* lo fa. Interagisci con un'interfaccia semplice e stabile e ignori l'implementazione disordinata dietro di essa.

## Che cosa vs. come

```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` non sa mai se è Stripe o PayPal — dipende dall'*idea* di addebitare, non dai dettagli.

## Astrazione vs. incapsulamento

Sono correlati ma distinti: l'**incapsulamento** nasconde lo stato per proteggerlo; l'**astrazione** nasconde la complessità per semplificare l'interfaccia. L'incapsulamento riguarda la *protezione*; l'astrazione riguarda *cosa mostrare*.

## Insidia

Le astrazioni leaky (dove i dettagli implementativi traspaiono) e le astrazioni premature (costruite prima di comprendere il problema) entrambi danneggiano. Astrai ciò che varia genuinamente.

## Perché è importante

L'astrazione è il modo in cui domari la complessità: i chiamanti ragionano su un'interfaccia piccola invece di un intero sottosistema.

Permette di scambiare le implementazioni — aggiungere un nuovo fornitore di pagamento tocca una sola classe, non ogni chiamante — che è il fondamento di un design flessibile e testabile.