Patrón de adaptador

Este patrón es fácil de entender ya que el mundo real está lleno de adaptadores. Por ejemplo, considere un adaptador USB a Ethernet. Necesitamos esto cuando tenemos una interfaz Ethernet en un extremo y USB en el otro. Ya que son incompatibles entre sí. usamos un adaptador que convierte uno a otro. Este ejemplo es bastante análogo a los adaptadores orientados a objetos. En diseño, los adaptadores se usan cuando tenemos una clase (Cliente) que espera algún tipo de objeto y tenemos un objeto (Adaptado) que ofrece las mismas características pero expone una interfaz diferente.

Para usar un adaptador:

1. El cliente realiza una solicitud al adaptador llamando a un método mediante la interfaz de destino.
2. El adaptador traduce esa solicitud en el adaptado usando la interfaz del adaptado.
3. El cliente recibe los resultados de la llamada y desconoce la presencia del adaptador.

Definición:

El patrón de adaptador convierte la interfaz de una clase en otra interfaz que esperan los clientes. El adaptador permite que las clases trabajen juntas que de otro modo no podrían debido a las interfaces incompatibles.

Diagrama de clase:

El cliente solo ve la interfaz de destino y no el adaptador. El adaptador implementa la interfaz de destino. El adaptador delega todas las requests a Adaptee.

Ejemplo:

Suponga que tiene una clase Bird con los métodos fly() y makeSound() . Y también una clase ToyDuck con el método squeak(). Supongamos que le faltan objetos ToyDuck y le gustaría usar objetos Bird en su lugar. Los pájaros tienen una funcionalidad similar pero implementan una interfaz diferente, por lo que no podemos usarlos directamente. Así que usaremos el patrón adaptador. Aquí nuestro cliente sería ToyDuck y el adaptado sería Bird.

A continuación se muestra la implementación de Java de la misma.

// Java implementation of Adapter pattern
  
interface Bird
{
    // birds implement Bird interface that allows
    // them to fly and make sounds adaptee interface
    public void fly();
    public void makeSound();
}
  
class Sparrow implements Bird
{
    // a concrete implementation of bird
    public void fly()
    {
        System.out.println("Flying");
    }
    public void makeSound()
    {
        System.out.println("Chirp Chirp");
    }
}
  
interface ToyDuck
{
    // target interface
    // toyducks dont fly they just make
    // squeaking sound
    public void squeak();
}
  
class PlasticToyDuck implements ToyDuck
{
    public void squeak()
    {
        System.out.println("Squeak");
    }
}
  
class BirdAdapter implements ToyDuck
{
    // You need to implement the interface your
    // client expects to use.
    Bird bird;
    public BirdAdapter(Bird bird)
    {
        // we need reference to the object we
        // are adapting
        this.bird = bird;
    }
  
    public void squeak()
    {
        // translate the methods appropriately
        bird.makeSound();
    }
}
  
class Main
{
    public static void main(String args[])
    {
        Sparrow sparrow = new Sparrow();
        ToyDuck toyDuck = new PlasticToyDuck();
  
        // Wrap a bird in a birdAdapter so that it 
        // behaves like toy duck
        ToyDuck birdAdapter = new BirdAdapter(sparrow);
  
        System.out.println("Sparrow...");
        sparrow.fly();
        sparrow.makeSound();
  
        System.out.println("ToyDuck...");
        toyDuck.squeak();
  
        // toy duck behaving like a bird 
        System.out.println("BirdAdapter...");
        birdAdapter.squeak();
    }
}

Producción:

Sparrow...
Flying
Chirp Chirp
ToyDuck...
Squeak
BirdAdapter...
Chirp Chirp

Explicación:
Supongamos que tenemos un pájaro que puede hacer Sonido(), y tenemos un pato de juguete de plástico que puede chirriar(). Ahora supongamos que nuestro cliente cambia el requisito y quiere que toyDuck haga un sonido que ?
La solución simple es que simplemente cambiaremos la clase de implementación a la nueva clase de adaptador y le diremos al cliente que pase la instancia del pájaro (que quiere chirriar()) a esa clase.
Antes: ToyDuck toyDuck = new PlasticToyDuck();
Después: ToyDuck toyDuck = new BirdAdapter (gorrión);
¡Puedes ver que al cambiar solo una línea, toyDuck ahora puede hacer Chirp Chirp!

Adaptador de objeto frente a adaptador de clase
El patrón de adaptador que hemos implementado anteriormente se llama patrón de adaptador de objeto porque el adaptador contiene una instancia de adaptee. También hay otro tipo llamado Patrón de adaptador de clase que usa herencia en lugar de composición, pero requiere herencia múltiple para implementarlo.
Diagrama de clase del patrón de adaptador de clase:

Aquí, en lugar de tener un objeto adaptado dentro del adaptador (composición) para hacer uso de su funcionalidad, el adaptador hereda el adaptado.

Dado que la herencia múltiple no es compatible con muchos lenguajes, incluido Java, y está asociada con muchos problemas, no hemos mostrado la implementación utilizando el patrón de adaptador de clase.

ventajas:

• Ayuda a lograr la reutilización y la flexibilidad.
• La clase de cliente no es complicada por tener que usar una interfaz diferente y puede usar polimorfismo para cambiar entre diferentes implementaciones de adaptadores.

Desventajas:

• Todas las requests se reenvían, por lo que hay un ligero aumento en los gastos generales.
• A veces se requieren muchas adaptaciones a lo largo de una string adaptadora para alcanzar el tipo que se requiere.

Lectura adicional: método de adaptador en Python

Referencias:
Head First Design Patterns (Libro)

Este artículo es una contribución de Sulabh Kumar. Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.