PATRÓN ADAPTER

Clasificación:

Patrón  Estructural.

Propósito:

Convertir la interfase de una clase en otra interfase que el cliente espera.  El adapter permite que clases trabajen juntas, mediante la sobreescritura de los métodos de las clases padre e implementada por el objeto adaptado, que de otra manera no podrian por las interfaces incompatibles.

También conocido como:

Wrapper.

Intención:

Se utiliza para transformar una interfaz en otra, de tal modo que una clase que no pudiera utilizar la primera, haga uso de ella a través de la segunda. Convierte la interfaz de una clase en otra interfaz que el cliente espera. Adapter permite a las clases trabajar juntas, lo que de otra manera no podrían hacerlo debido a sus interfaces incompatibles

Motivación :

Este patrón se centra en resolver incompatibilidades entre dos interfaces existentes. Se utiliza para hacer funcionar las cosas después de que estas han sido diseñadas.

Aplicabilidad:

Se utiliza el  patrón Adapter cuando se desea utilizar una clase existente, y su interfaz no coincide con  una que usted necesita. Debe crear una clase reutilizable que coopere con o sin relación  de clases, es decir, clases que no tienen necesariamente interfaces compatibles .

Estructura :

La estructura de un class Adapter usa  herencia de una clase, e implementación de una interfaz  para adaptar un objeto que posea características de ambos.

Participantes:

• Target
• Define el dominio de la interfaz que el Cliente usa.
• Cliente
• Colabora con los objetos conformando la interfaz del  Target.
• Adaptee (el adaptado)
• Define la interfaz existente que necesita adaptación.
• Adapter
• Adapta la interfase Adaptee para usar en el objeto de Target.

Colaboraciones :

El Cliente llama a las operaciones en la instancia del Adapter.  Luego, el Adapter llama alAdaptee (el Adaptado) y lleva a cabo las operaciones pedidas

 

Object Adapter: 

El object adapter  adapta las clases, no instancias u objetos. Esto puede traer problemas a la hora de instanciar esas clases adaptadas ya que puede ocurrir que el objeto que se  tiene no sea lo que se necesita. En caso de que se necesite, ha de  saberse que objetos hay que adaptar cuando son llamados por el cliente,  o mejor dicho cuando ni bien se realice la “adaptación” se  puede usar una pequeña variante del Adapter, llamado Object Adapter

El object adapter trabaja creando una clase Adapter que solamente implemente la interfaz y contiene una instancia de la clase, o sea, un objeto a adaptar. No es necesario heredar la clase a adaptar porque en realidad se va  a trabajar con una instancia de esta.           

Cuándo emplearlo:

·     Se quiere usar una clase existente, y su interfaz no concuerda con la que se necesita.

·     Se quiere crear una clase reusable que coopere con clases no relacionadas o imprevistas, esto es,  clases que no tienen interfases compatibles necesariamente.

·     (object adapter solamente) necesita usar varias subclases existentes, pero no es practico adaptar sus interfases haciendo “subclassing” por cada una. Un object adapter puede adaptar la interfaz de sus clase padre (parent).

Consecuencias :

     Class Adapter 

·     Adapta el Adaptee al Target informando a un class Adapter concreto. Comoconsecuencia, un class Adapter no funciona cuando se quiere adaptar una clase y todas sus subclases (subclassing).

·    El Adapter sobreescribe el comportamiento del Adaptee ya que el Adapter es una subclase del Adapteee .

·     Introduce solamente un objeto y no hay un  puntero adicional para conseguir el Adaptee.

Object Adapter 

·      Un Adapter puede trabajar con multiples Adaptees, esto es, el Adaptee en si y todas sus subclases.

·     Hace más dificil de sobreescribir el comportamiento del Adpatee. Requerirá hacer subclasssing del Adaptee y hacer que el Adapter se remita a las subclases en vez delAdaptee en si.

Implementación :

El siguiente ejemplo ilustra  el patrón Adapter, el ejemplo trata de una  tienda de tortas, donde el usuario puede elegir una torta normal y/o agregarle algunas especificaciones disponibles, como lo son diferentes sabores de cubiertas para la decoración. 

Creamos la interfaz que permite adicionar características adicionales al objeto.

package logica;

//es nuestra clase Adaptee//

public interface Adaptee {    //*la interfaz Adaptee permite adicionar a la torta 

      public void decorar();   // diferentes características *//

      public voidcubiertaFresa();

      public voidcubiertaNaranja();

      public voidcubiertaCaramelo();

      public voidcubiertaChocolate();

}

Ahora la clase que  adapta el objeto al la interfaz; permitiendo combinar las características de ambas.

package logica;

//nuestra clase Adapter//

public class Adapter extendsTorta implements Adaptee{    

         //*esta clase es la adaptadora, donde el objeto creado

       //hereda de torta y puede tener caracteriaticas 

      // especiales dadas por la interfaz Adaptee*//

String Cubierta;

String FiguraEspecial;

      public Adapter(){  //constructor de la clase//

            Cubierta="Sin Cubierta";

            FiguraEspecial="";

      }   

  //obtiene un String con el nombre del sabor de la cubierta//

      public String getCubierta(){  

            return this.Cubierta;   

      }    

//obtiene un String que dice si el objeto posee una figura decorativa//

      public String getDecoracion(){  

            returnthis.FiguraEspecial; 

      }    

      @Override

// metodo de la interfaz; asigna el nombre del sabor de la cubierta//

      public voidcubiertaChocolate() { 

            Cubierta="Con Cubierta de Chocolate";              }

      @Override

      public voidcubiertaFresa() {

            Cubierta="Con Cubierta de Fresa";       

      }

      @Override

      public voidcubiertaNaranja() {

            Cubierta="Con Cubierta de Naranja";     

      }

      @Override

      public voidcubiertaCaramelo() {

            Cubierta="Con Cubierta de Caramelo";          

      }

      @Override

//es un metodo de la interfaz//

      public void decorar() { 

//asigna una figura decorativa al objeto//

           FiguraEspecial="Decorada Con Figura Especial";      

      }    

      @Override

//retorna la descripcion la cubierta de la torta//

    public String pedidoCubierta(){

            return "Su pedido esta listo: **TORTA **\n"+this.getCubierta();

      }

      @Override

//retorna la descripcion de la decoración//

      public String pedidoDecoracion() {

            returnthis.getDecoracion();      

      }

}

Esta es la clase principal la cual debe ser abstracta, permitiendo de este modo tener métodos abstractos, que serán comunes simpre a cualquier pedido. 

package logica;

//nuestra clase Target//

//*clase principal a la que siempre pertenecerá el objeto creado la cual posee metodos abstractos//

public abstract class Torta {

      public abstract String pedidoCubierta();

      public abstract String pedidoDecoracion();

}

Por último, creamos la interfaz la cual presenta una ventana que permite al cliente elegir las características de la torta.

package intefaz;

import logica.*; 

import java.awt.event.*;

import javax.swing.*;

 //interfaz para la toma del pedido//

public class OrdenPasteleria extends JFrame implements ActionListener {

            Adapter torta;    

            private JButton figuraDecorativa; 

            private JButton cubiertaFresa;

            private JButton cubiertaCaramelo;

            private JButton cubiertaChocolate;

            private JButton cubiertaNaranja;

            private JTextArea suOrden;

            private JLabel orden;

           //constructor: inicializa y localizan los atributos//

            public OrdenPasteleria(){   

            this.setSize(400,300);               

            this.setLayout(null);

            this.setDefaultCloseOperation(OrdenPasteleria.DISPOSE_ON_CLOSE);

            this.setTitle(":;;Pasteleria UD:::");

       

            torta= new Adapter();       

            orden = new JLabel();

            orden.setSize(350,20);

            orden.setLocation(20, 20);

            orden.setText("Seleccione las características de su Torta ");

            this.getContentPane().add(orden);       

            suOrden = new JTextArea();

            suOrden.setSize(350,50);

            suOrden.setLocation(20, 200);

            suOrden.setText("Usted tiene una Torta " + torta.getCubierta());

            this.getContentPane().add(suOrden);

            suOrden.setEditable(false);    

           figuraDecorativa = new JButton();

           figuraDecorativa.setSize(150, 25);

           figuraDecorativa.setLocation(100, 150);

           figuraDecorativa.setText("Figura Especial");

           this.getContentPane().add(figuraDecorativa);

           figuraDecorativa.addActionListener(this);  

           cubiertaFresa = new JButton();

           cubiertaFresa.setSize(170, 30);

           cubiertaFresa.setLocation(20, 50);

           cubiertaFresa.setText("Cubierta de Fresa");

           this.getContentPane().add(cubiertaFresa);

           cubiertaFresa.addActionListener(this); 

           cubiertaCaramelo = new JButton();

           cubiertaCaramelo.setSize(170, 30);

           cubiertaCaramelo.setLocation(200, 50);

           cubiertaCaramelo.setText("Cubierta de Caramelo");

           this.getContentPane().add(cubiertaCaramelo);

           cubiertaCaramelo.addActionListener(this);        

           cubiertaChocolate = new JButton();

           cubiertaChocolate.setSize(170, 30);

           cubiertaChocolate.setLocation(20, 100);

           cubiertaChocolate.setText("Cubierta de Chocolate");

           this.getContentPane().add(cubiertaChocolate);

           cubiertaChocolate.addActionListener(this);       

           cubiertaNaranja = new JButton();

           cubiertaNaranja.setSize(170, 30);

           cubiertaNaranja.setLocation(200, 100);

           cubiertaNaranja.setText("Cubierta de Naranja");

           this.getContentPane().add(cubiertaNaranja);

           cubiertaNaranja.addActionListener(this);

       }         

      @Override

//modifica  el objeto a peticion del cliente//

      public void actionPerformed(ActionEvent e) {          

           if (e.getSource() == figuraDecorativa) { 

               torta.decorar();

           }

          if (e.getSource() == cubiertaFresa){

             torta.cubiertaFresa();

           }

         if (e.getSource() == cubiertaCaramelo) {

           torta.cubiertaCaramelo();

          }

         if (e.getSource() == cubiertaChocolate) {

           torta.cubiertaChocolate();

         }

        if (e.getSource() == cubiertaNaranja) {

            torta.cubiertaNaranja();

        }

        suOrden.setSize(350,50);

        suOrden.setLocation(20, 200);

       //muestra el pedido como tal, las características de la torta//

       suOrden.setText(torta.pedidoCubierta()+'\n'+torta.pedidoDecoracion());

    } 

}

Usos conocidos:

Clases adaptadoras del JDK

• Para gestionar eventos un objeto debe implementar EventListener
• Para gestionar eventos de objetos de tipo Windowdebe implementar la interfaz WindowListenerque extiende EventListener
• WindowListenertiene siete métodos, pero en muchas ocasiones sólo no se usan más de tres. 
• El JDK proporciona la clase abstracta WindowAdapterpara dicho fin.    

Patrones relacionados : 

·       Bridge : Tiene una estructura similar alAdapter, pero un intento diferente : Su proposito es separar la interfase de su implementación asi esta puede variar facilmente y de forma independiente. El proposito del Adapter es el cambio de interfase de un objeto existente.

 

·      Decorator : Agrega resonsabilidades a un objeto dinamicamente sin cambiar su interfase .

Un Decorator en cambio es mas transparente a la aplicación que un Adapter, como consecuencia

Soporta composición recursiva,  lo cual no es posible con el patronAdapter.

 

·         Proxy : Define un lugar para otro objeto para controlar el acceso y no cambia su interfase.

REFERENCIAS: 

Design Patterns: Elements of Reusable Object-Oriented Software Gamma, Helm, Johnson, Vlissides Editorial Addison-Wesley