Patrón Adapter

from abc import ABC, abstractmethod


class Pago(ABC):
    """La interfaz que usa nuestro programa."""
    @abstractmethod
    def cobrar(self, euros): ...


class TarjetaPropia(Pago):
    def cobrar(self, euros):
        print(f"Tarjeta: cobrados {euros:.2f} €".replace(".", ","))
        return True


class PasarelaExterna:
    """Una biblioteca de terceros: no se puede cambiar y su interfaz no es la nuestra."""
    def realizar_cargo(self, centimos, moneda):
        if centimos > 50_000:
            return "KO-LIMITE"
        print(f"Pasarela: cargo de {centimos} céntimos en {moneda}")
        return "OK"


class PasarelaAdapter(Pago):
    """El adaptador: tiene la interfaz que espera nuestro código y traduce cada llamada a la pasarela."""
    def __init__(self, pasarela):
        self._pasarela = pasarela

    def cobrar(self, euros):
        centimos = round(euros * 100)                                  # euros → céntimos
        return self._pasarela.realizar_cargo(centimos, "EUR") == "OK"  # "OK" / "KO-…" → True / False


class Tienda:
    """El cliente: solo conoce Pago, así que acepta la pasarela sin cambiar una línea."""
    def finalizar_compra(self, pago, total):
        print("Compra pagada" if pago.cobrar(total) else "Pago rechazado")


tienda = Tienda()
tienda.finalizar_compra(TarjetaPropia(), 12.5)
pasarela = PasarelaAdapter(PasarelaExterna())
tienda.finalizar_compra(pasarela, 89.99)
tienda.finalizar_compra(pasarela, 600)

// La «interfaz» que usa nuestro programa: cualquier objeto con cobrar(euros)
class TarjetaPropia {
    cobrar(euros) {
        console.log(`Tarjeta: cobrados ${euros.toFixed(2).replace(".", ",")} €`);
        return true;
    }
}

/** Una biblioteca de terceros: no se puede cambiar y su interfaz no es la nuestra. */
class PasarelaExterna {
    realizarCargo(centimos, moneda) {
        if (centimos > 50_000) return "KO-LIMITE";
        console.log(`Pasarela: cargo de ${centimos} céntimos en ${moneda}`);
        return "OK";
    }
}

/** El adaptador: tiene la interfaz que espera nuestro código y traduce cada llamada a la pasarela. */
class PasarelaAdapter {
    constructor(pasarela) { this.pasarela = pasarela; }

    cobrar(euros) {
        const centimos = Math.round(euros * 100);                       // euros → céntimos
        return this.pasarela.realizarCargo(centimos, "EUR") === "OK";   // "OK" / "KO-…" → true / false
    }
}

/** El cliente: solo usa cobrar, así que acepta la pasarela sin cambiar una línea. */
class Tienda {
    finalizarCompra(pago, total) {
        console.log(pago.cobrar(total) ? "Compra pagada" : "Pago rechazado");
    }
}

const tienda = new Tienda();
tienda.finalizarCompra(new TarjetaPropia(), 12.5);
const pasarela = new PasarelaAdapter(new PasarelaExterna());
tienda.finalizarCompra(pasarela, 89.99);
tienda.finalizarCompra(pasarela, 600);

using System;
using System.Globalization;

// La interfaz que usa nuestro programa.
interface IPago {
    bool Cobrar(decimal euros);
}

class TarjetaPropia : IPago {
    public bool Cobrar(decimal euros) {
        Console.WriteLine(
quot;Tarjeta: cobrados {euros.ToString("F2", CultureInfo.InvariantCulture).Replace('.', ',')} €");
        return true;
    }
}

// Una biblioteca de terceros: no se puede cambiar y su interfaz no es la nuestra.
class PasarelaExterna {
    public string RealizarCargo(long centimos, string moneda) {
        if (centimos > 50_000) return "KO-LIMITE";
        Console.WriteLine(
quot;Pasarela: cargo de {centimos} céntimos en {moneda}");
        return "OK";
    }
}

// El adaptador: tiene la interfaz que espera nuestro código y traduce cada llamada a la pasarela.
class PasarelaAdapter : IPago {
    private readonly PasarelaExterna pasarela;
    public PasarelaAdapter(PasarelaExterna pasarela) => this.pasarela = pasarela;

    public bool Cobrar(decimal euros) {
        long centimos = (long)Math.Round(euros * 100);                  // euros → céntimos
        return pasarela.RealizarCargo(centimos, "EUR") == "OK";          // "OK" / "KO-…" → true / false
    }
}

// El cliente: solo conoce IPago, así que acepta la pasarela sin cambiar una línea.
class Tienda {
    public void FinalizarCompra(IPago pago, decimal total) {
        Console.WriteLine(pago.Cobrar(total) ? "Compra pagada" : "Pago rechazado");
    }
}

class Program {
    static void Main() {
        var tienda = new Tienda();
        tienda.FinalizarCompra(new TarjetaPropia(), 12.5m);
        IPago pasarela = new PasarelaAdapter(new PasarelaExterna());
        tienda.FinalizarCompra(pasarela, 89.99m);
        tienda.FinalizarCompra(pasarela, 600m);
    }
}

<?php
/** La interfaz que usa nuestro programa. */
interface Pago {
    public function cobrar(float $euros): bool;
}

class TarjetaPropia implements Pago {
    public function cobrar(float $euros): bool {
        echo "Tarjeta: cobrados ", number_format($euros, 2, ",", ""), " €\n";
        return true;
    }
}

/** Una biblioteca de terceros: no se puede cambiar y su interfaz no es la nuestra. */
class PasarelaExterna {
    public function realizarCargo(int $centimos, string $moneda): string {
        if ($centimos > 50000) return "KO-LIMITE";
        echo "Pasarela: cargo de $centimos céntimos en $moneda\n";
        return "OK";
    }
}

/** El adaptador: tiene la interfaz que espera nuestro código y traduce cada llamada a la pasarela. */
class PasarelaAdapter implements Pago {
    public function __construct(private PasarelaExterna $pasarela) {}

    public function cobrar(float $euros): bool {
        $centimos = (int) round($euros * 100);                            // euros → céntimos
        return $this->pasarela->realizarCargo($centimos, "EUR") === "OK"; // "OK" / "KO-…" → true / false
    }
}

/** El cliente: solo conoce Pago, así que acepta la pasarela sin cambiar una línea. */
class Tienda {
    public function finalizarCompra(Pago $pago, float $total): void {
        echo $pago->cobrar($total) ? "Compra pagada" : "Pago rechazado", "\n";
    }
}

$tienda = new Tienda();
$tienda->finalizarCompra(new TarjetaPropia(), 12.5);
$pasarela = new PasarelaAdapter(new PasarelaExterna());
$tienda->finalizarCompra($pasarela, 89.99);
$tienda->finalizarCompra($pasarela, 600);

import io

# TextIOWrapper adapta un flujo de bytes a uno de texto (lo que hace open() por dentro)
binario = open("notas.csv", "rb")
texto = io.TextIOWrapper(binario, encoding="utf-8")

# En Python basta con tener los métodos que se esperan («duck typing»): un adaptador es
# cualquier clase que los ofrezca y llame por dentro a la que no encaja.
class LectorDeLista:
    def __init__(self, lineas):
        self._lineas = iter(lineas)

    def readline(self):                  # la interfaz que espera quien lee ficheros
        return next(self._lineas, "")

// util.promisify adapta una función con callback a una que devuelve una promesa
import { promisify } from "node:util";
import { readFile } from "node:fs";

const leer = promisify(readFile);
const contenido = await leer("notas.csv", "utf8");

// Array.from adapta cualquier cosa iterable o con length (un NodeList, un Set) a un array
const botones = Array.from(document.querySelectorAll("button"));

// StreamReader adapta un Stream (bytes) a un TextReader (caracteres)
using var lector = new StreamReader(File.OpenRead("notas.csv"), Encoding.UTF8);

// AsReadOnly adapta una List<T> a la interfaz IReadOnlyList<T> sin copiarla
IReadOnlyList<string> ciclos = new List<string> { "DAM", "DAW" }.AsReadOnly();

// En Android con Xamarin/MAUI, los Adapter de las listas convierten datos en filas de la pantalla

<?php
// ArrayIterator adapta un array a la interfaz Iterator de la SPL
$it = new ArrayIterator(["DAM", "DAW", "ASIR"]);
foreach ($it as $ciclo) echo $ciclo, "\n";

// Los frameworks definen interfaces (PSR) y cada biblioteca trae su adaptador: Flysystem, por
// ejemplo, usa la misma interfaz para guardar ficheros en disco, en S3 o por FTP.
$disco = new League\Flysystem\Filesystem(new League\Flysystem\Local\LocalFilesystemAdapter("/datos"));