O que é o padrão adaptador?

O padrão adaptador (Adapter Pattern) é um padrão estrutural de design que permite que classes com interfaces incompatíveis trabalhem juntas. Funciona como uma camada que transforma a interface de uma classe na outra que o cliente espera.

Aplicações:

• Integração de bibliotecas de terceiros com interfaces incompatíveis.
• Uso de classes existentes em novos sistemas sem modificá-las.
• Garantir a interação entre classes desenvolvidas de forma independente.

Exemplo de implementação (adaptador de objetos):

Suponha que exista uma classe LegacyService com um método oldRequest():

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

E uma nova interface NewService com um método newRequest():

interface NewService {
    void newRequest();
}

O adaptador ServiceAdapter implementa NewService e contém uma referência a LegacyService:

class ServiceAdapter implements NewService {
    private LegacyService legacyService;

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

    @Override
    public void newRequest() {
        // Transformação da chamada do novo método para o antigo
        legacyService.oldRequest();
    }
}

O cliente pode usar LegacyService através da interface NewService:

NewService service = new ServiceAdapter(new LegacyService());
service.newRequest(); // Chama oldRequest() em LegacyService

Também existe uma variante chamada adaptador de classe, que usa herança múltipla (se a linguagem suportar) ou herança da classe a adaptar e a implementação da interface alvo. Em Java, devido à ausência de herança múltipla, ela é implementada através de herança da classe a adaptar e implementação da interface do adaptador, embora essa abordagem seja menos flexível. O adaptador de objetos é preferido porque permite adaptar subclasses e evitar uma ligação rígida.

Vantagens:

• Permite a reutilização de classes incompatíveis.
• Encapsula os detalhes da transformação de interfaces.
• Aumenta a flexibilidade do sistema.

Desvantagens:

• Pode aumentar a complexidade ao adicionar uma nova classe.
• O desempenho pode diminuir um pouco devido a um nível adicional de abstração.