¿Qué es la abstracción en OOP?

Question

Accepted Answer

**Abstracción** significa exponer *qué* hace un objeto mientras se oculta *cómo* lo hace. Interactúas con una interfaz simple y estable, ignorando la implementación complicada detrás de ella.

## Qué versus cómo

```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` nunca sabe si es Stripe o PayPal — depende de la *idea* de cobrar, no de los detalles.

## Abstracción versus encapsulación

Están relacionadas pero son distintas: **encapsulación** oculta el estado para protegerlo; **abstracción** oculta la complejidad para simplificar la interfaz. La encapsulación trata sobre *protección*; la abstracción trata sobre *qué mostrar*.

## Trampa

Las abstracciones con fugas (donde los detalles de implementación se filtran) y las abstracciones prematuras (construidas antes de entender el problema) ambas dañan. Abstrae lo que realmente varía.

## Por qué es importante

La abstracción es cómo domesticas la complejidad: los llamadores razonan sobre una interfaz pequeña en lugar de un subsistema completo.

Habilita intercambiar implementaciones — agregar un nuevo proveedor de pago toca una clase, no cada llamador — lo cual es la base del diseño flexible y comprobable.