¿Qué es el patrón adaptador?

El patrón adaptador (Adapter Pattern) es un patrón estructural de diseño que permite que clases con interfaces incompatibles trabajen juntas. Funciona como un envoltorio que transforma la interfaz de una clase en otra que el cliente espera.

Aplicaciones:

• Integración de bibliotecas de terceros con interfaces incompatibles.
• Uso de clases existentes en nuevos sistemas sin modificarlas.
• Garantizar la interacción entre clases desarrolladas de forma independiente.

Ejemplo de implementación (adaptador de objetos):

Supongamos que existe una clase LegacyService con un método oldRequest():

class LegacyService {
    public void oldRequest() {
        // código antiguo
    }
}

Y una nueva interfaz NewService con un método newRequest():

interface NewService {
    void newRequest();
}

El adaptador ServiceAdapter implementa NewService y contiene una referencia a LegacyService:

class ServiceAdapter implements NewService {
    private LegacyService legacyService;

    public ServiceAdapter(LegacyService legacyService) {
        this.legacyService = legacyService;
    }

    @Override
    public void newRequest() {
        // Transformación de la llamada del nuevo método a la antigua
        legacyService.oldRequest();
    }
}

El cliente puede usar LegacyService a través de la interfaz NewService:

NewService service = new ServiceAdapter(new LegacyService());
service.newRequest(); // Llamará a oldRequest() en LegacyService

También existe una variante llamada adaptador de clase, que usa herencia múltiple (si el lenguaje lo soporta) o herencia de la clase a adaptar y la implementación de la interfaz objetivo. En Java, debido a la falta de herencia múltiple, se implementa mediante herencia de la clase adaptada y la implementación de la interfaz del adaptador, aunque este enfoque es menos flexible. El adaptador de objetos es preferible porque permite adaptar subclases y evita una conexión rígida.

Ventajas:

• Permite la reutilización de clases incompatibles.
• Encapsula los detalles de la transformación de interfaces.
• Mejora la flexibilidad del sistema.

Desventajas:

• Puede aumentar la complejidad al agregar una nueva clase.
• El rendimiento puede disminuir ligeramente debido a un nivel adicional de abstracción.