Adapter

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Ambox rewrite.svg
Esta página precisa ser reciclada de acordo com o livro de estilo (desde outubro de 2016).
Sinta-se livre para editá-la para que esta possa atingir um nível de qualidade superior.
Emblem-question.svg
Este artigo ou se(c)ção pode conter texto de natureza não enciclopédica. (desde outubro de 2016)
Justifique o uso dessa marcação e tente resolver essas questões na página de discussão.
Question book.svg
Esta página ou secção não cita fontes confiáveis e independentes, o que compromete sua credibilidade (desde janeiro de 2014). Por favor, adicione referências e insira-as corretamente no texto ou no rodapé. Conteúdo sem fontes poderá ser removido.
Encontre fontes: Google (notícias, livros e acadêmico)

Adapter (Adaptador, ou também conhecido como Wrapper) é um dos padrões de projeto estruturais do GoF (Gang of Four).

O padrão Adapter converte uma interface de uma classe para outra interface que o cliente espera encontrar. O Adaptador permite que classes com interfaces incompatíveis trabalhem juntas.

Exemplo de diagrama do padrão Adapter

Descrição das classes de acordo com o diagrama UML[editar | editar código-fonte]

Target (Alvo)

  • Define a interface do domínio específico que o cliente utiliza.

Adapter (Adaptador)

  • Adapta a interface Adaptee para a interface da classe Target.

Adaptee (Adaptada)

  • Define uma interface existente que necessita ser adaptada.

Client (Cliente)

  • Colabora com os objetos em conformidade com a interface Target.

Consequências[editar | editar código-fonte]

Cada adaptador de classes e de objetos tem diferentes soluções de compromisso. Um adaptador de classe:

  • adapta a classe Adaptee a Target através do uso efetivo de uma classe Adapter concreta. Em consequência disso, um adaptador de classe não funcionará quando quisermos adaptar uma classe e todas as suas subclasses;
  • permite que a classe Adapter substitua algum comportamento da classe Adaptee, uma vez que Adapter é uma subclasse de Adaptee;
  • introduz somente um objeto, e não é necessário endereçamento indireto adicional por ponteiros para chegar até a classe Adaptee.

Um adaptador de objeto:

  • permite a um único Adapter trabalhar com muitos Adaptees, ou seja, o Adaptee em si e todas as suas subclasses (caso existam);
  • torna mais difícil redefinir um comportamento de uma classe Adaptee. Ele exigirá a criação de subclasses de Adaptee e fará com que a classe Adapter referencie a subclasse, ao invés da classe Adaptee em si.

Motivação[editar | editar código-fonte]

Muitas vezes uma classe que poderia ser reaproveitada não é reutilizada justamente pelo fato de sua interface não corresponder à interface específica de um domínio requerida por uma aplicação.

Aplicabilidade[editar | editar código-fonte]

O padrão Adapter pode ser utilizado quando:

  • se deseja utilizar uma classe existente, porém sua interface não corresponde à interface que se necessita;
  • o desenvolvedor quiser criar classes reutilizáveis que cooperem com classes não-relacionadas ou não-previstas, ou seja, classes que não possuem necessariamente interfaces compatíveis;
  • (exclusivamente para adaptadores de objetos) é necessário utilizar muitas subclasses existentes, porém, impossível de adaptar essas interfaces criando subclasses para cada uma. Um adaptador de objeto pode adaptar a interface de sua classe mãe.

Exemplos[editar | editar código-fonte]

Adaptador de Objeto[editar | editar código-fonte]

Código em Java e Diagrama UML de classes[editar | editar código-fonte]

Um exemplo do padrão adapter, onde adaptamos a EntradaPS2 para EntradaUSB
//Classe adaptada(Adaptee)
class EntradaPS2 {

//Solicitação Especifica
    public void conectarEntradaPS2() {
        System.out.println("Conectado na entrada PS2");
    }
}

//Classe alvo(Target)
class EntradaUSB {

//Solicitação
    public void conectarEntradaUSB() {
        System.out.println("Conectado na entrada USB");
    }
}

//Classe adaptador(Adapter)
class AdapterEntrada extends EntradaUSB {

    private EntradaPS2 entradaPS2;

    public AdapterEntrada(EntradaPS2 entradaPs2) {
        this.entradaPS2 = entradaPs2;
    }

//Solicitação
    public void conectarEntradaUSB() {
        entradaPS2.conectarEntradaPS2();
    }
}

//Classe Cliente(Client)
public class Teclado {

    public static void main(String[] args) {
        EntradaPS2 ps2 = new EntradaPS2();
        AdapterEntrada adaptador = new AdapterEntrada(ps2);
        adaptador.conectarEntradaUSB();
    }
}

Código em C#[editar | editar código-fonte]

namespace PadraoAdapter
{
    class EntradaPS2
    {

        //Solicitação Especifica
        public void conectarEntradaPS2()
        {
            Console.Write("Conectado na entrada PS2");
        }
    }

    //Classe alvo(Target)
    class EntradaUSB
    {

        //Solicitação
        public void conectarEntradaUSB()
        {
            Console.Write("Conectado na entrada USB");
        }
    }

    //Classe adaptador(Adapter)
    class AdapterEntrada : EntradaUSB
    {

        private EntradaPS2 entradaPS2;

        public AdapterEntrada(EntradaPS2 entradaPs2)
        {
            this.entradaPS2 = entradaPs2;
        }

        //Solicitação
        public void conectarEntradaUSB()
        {
            entradaPS2.conectarEntradaPS2();
        }
    }

    class Teclado
    {
        static void Main(string[] args)
        {
            EntradaPS2 ps2 = new EntradaPS2();
            AdapterEntrada adaptador = new AdapterEntrada(ps2);
            adaptador.conectarEntradaUSB();
        }
    }
}

Adaptador de Classe[editar | editar código-fonte]

Código em Java e diagrama UML de classes[editar | editar código-fonte]

A classe adaptador adapta a InterfaceCliente e a ClasseExistente
class ClasseExistente {

    public void exibir() {
        System.out.println("Metodo exibir()");
    }
}

interface InterfaceCliente {

    public void mostrar();
}

class Adaptador extends ClasseExistente implements InterfaceCliente {

    public void mostrar() {
        exibir();
    }
}
public class Cliente
    {

       public static void Main(string[] args)
        {
            InterfaceCliente existente = new Adaptador();
            existente.mostrar();
        }
    }

Código em C#[editar | editar código-fonte]

namespace PadraoAdapter
{
    //Adaptada(adaptee)
    class ClasseExistente
    {

        public void exibir()
        {
            Console.Write("Metodo exibir()");
        }
    }
    //Adaptada(adaptee)
    interface InterfaceCliente
    {

        void mostrar();
    }
    //Adaptador(adapter)
    class Adaptador : ClasseExistente, InterfaceCliente
    {

        public void mostrar()
        {
            exibir();
        }
    }

    class Cliente
    {

        static void Main(string[] args)
        {
            InterfaceCliente existente = new Adaptador();
            existente.mostrar();
        }
    }
}

Padrões relacionados[editar | editar código-fonte]

O padrão GoF Bridge possui uma estrutura similar a um adaptador de objeto propriamente dito, mas esse padrão tem uma intenção diferente: tem como objetivo separar uma interface da sua implementação, de uma forma que elas possam variar fácil e independentemente. Um adaptador do padrão Adapter se destina a mudar a interface de um objeto existente.

Outro padrão estrutural GoF que podemos citar é o Decorator, que por sua vez, aumenta outro objeto sem mudar sua interface. Desta forma, um Decorator é mais transparente para a aplicação do que um adaptador de Adapter.

Como consequência, o Decorator suporta a composição recursiva, a qual não é possível com adaptadores puros.

Por fim, o padrão Proxy, que também é um padrão estrutural, permite a definição de um representante ou “procurador” para outro objeto e não muda sua interface.

Ícone de esboço Este artigo sobre Informática é um esboço. Você pode ajudar a Wikipédia expandindo-o.