O que é o padrão Adapter?

Question

Accepted Answer

O padrão **Adapter** permite que objetos com **interfaces incompatíveis** trabalhem juntos envolvendo um deles com a interface que o outro espera. Ele atua como um tradutor entre duas interfaces, possibilitando integração sem modificar o código existente.

## O que o padrão Adapter faz

```text
ADAPTER → convert one interface into another that a client expects (a "translator"):
  → wrap an object whose interface is INCOMPATIBLE, exposing the interface the client needs
  → the adapter translates calls/data between the two interfaces
→ makes incompatible things work together WITHOUT changing either's code
```

## Exemplo

```js
// a third-party library with an incompatible interface
class ThirdPartyLogger { logMessage(text) { /* ... */ } }

// our code expects a .log(msg) interface → adapt it
class LoggerAdapter {
  constructor(thirdParty) { this.logger = thirdParty; }
  log(msg) { this.logger.logMessage(msg); }   // translate our interface to theirs
}
const logger = new LoggerAdapter(new ThirdPartyLogger());
logger.log('hello');   // our code uses .log; the adapter calls .logMessage
```

## Usos e benefícios

```text
USES → integrate THIRD-PARTY libraries with incompatible interfaces; make legacy code work
  with new code; unify different APIs behind a common interface; swap implementations
BENEFITS:
  ✓ INTEGRATION → make incompatible interfaces work together without modifying either
  ✓ DECOUPLING → your code depends on YOUR interface; adapters isolate external/incompatible
    code → swap or upgrade dependencies behind the adapter
  ✓ Reuse existing code that doesn't quite fit
```

## Por que isso importa

Entender o padrão Adapter é valioso porque é um **padrão estrutural muito comum e prático** para integrar código incompatível, tornando-se conhecimento de design relevante.

O padrão Adapter permite que objetos com **interfaces incompatíveis trabalhem juntos** envolvendo um deles com a interface que o outro espera — atuando como um tradutor entre interfaces.

Entender o que ele faz (envolver um objeto com uma interface incompatível para expor a interface que o cliente precisa, traduzindo entre as duas) é o conhecimento central.

Entender os **usos** é especialmente valioso porque eles são necessidades comuns e reais: **integrar bibliotecas de terceiros** com interfaces incompatíveis (uma situação frequente — você precisa usar uma biblioteca, mas sua interface não corresponde ao seu código), fazer **código legado trabalhar com código novo**, unificar diferentes APIs atrás de uma interface comum e permitir a troca de implementações.

Essas necessidades de integração surgem constantemente no desenvolvimento real.

Entender os **benefícios** — **integração** (fazer interfaces incompatíveis funcionarem juntas sem modificar nenhuma delas, o que é frequentemente necessário quando você não pode alterar código de terceiros ou legado), e **desacoplamento** (seu código dependendo de sua própria interface enquanto adaptadores isolam código externo/incompatível, para que você possa trocar ou atualizar dependências atrás do adapter — um benefício arquitetônico valioso) — esclarece por que Adapter é praticamente importante.

O padrão Adapter é um dos padrões mais praticamente úteis porque integrar código incompatível (bibliotecas de terceiros, sistemas legados, diferentes APIs) é uma necessidade constante e real no desenvolvimento.

Como o padrão Adapter é um padrão muito comum e prático para integrar interfaces incompatíveis (bibliotecas de terceiros, código legado, diferentes APIs) sem modificar nenhuma delas — uma necessidade real constante — e fornece desacoplamento valioso, e como entender o que ele faz, seus usos e seus benefícios é relevante para o trabalho de integração real, entender o padrão Adapter é conhecimento de design valioso e praticamente relevante — um padrão frequentemente necessário para a tarefa comum de integrar código incompatível, fornecendo integração e desacoplamento, e conhecimento de design importante para o desafio real e recorrente de fazer diferentes partes do código funcionarem juntas.