Este patrón permite que trabajen juntas clases con interfaces incompatibles.
Para ello, un objeto adaptador reenvía al otro objeto los datos que recibe (a través de los métodos que implementa, definidos en una clase abstracta o interface) tras manipularlos en caso necesario.
Veamos un pequeño programa de ejemplo en el que utilizamos este patrón de diseño (usando composición), creando un objeto adaptador que convierte de pesetas a euros para poder comunicarse con otro objeto que gestiona los movimientos de una caja en euros:
Main.java (Cliente según el diagrama anterior):
package estructurales.adapter.adapter01;
public class Main
{
public static void main(String[] args)
{
Adaptador conversor = new Adaptador();
conversor.ingresarPesetas( 2000 );
conversor.ingresarPesetas( 5000 );
conversor.ingresarPesetas( 1000 );
System.out.println( "Total euros: " + conversor.getSaldo() );
}
}
IAdaptador.java (Objetivo según el diagrama anterior):
package estructurales.adapter.adapter01;
public interface IAdaptador
{
public abstract void sacarPesetas( double pesetas );
public abstract void ingresarPesetas( double pesetas );
}
Adaptador.java:
package estructurales.adapter.adapter01;
public class Adaptador implements IAdaptador
{
CajaEuros cajaEuros = new CajaEuros();
// ------------------
public Adaptador() {
}
// ------------------
public double getSaldo()
{
return this.cajaEuros.getTotalEuros();
}
// ------------------
@Override
public void sacarPesetas( double pesetas )
{
double euros = pesetas / 166.386;
cajaEuros.sacarEuros( euros );
}
// ------------------
@Override
public void ingresarPesetas( double pesetas )
{
double euros = pesetas / 166.386;
cajaEuros.ingresarEuros( euros );
}
}
CajaEuros.java (Adaptable según el diagrama anterior):
package estructurales.adapter.adapter01;
public class CajaEuros
{
private double euros = 0;
// -----------------
public CajaEuros() {
}
// -----------------
public double getTotalEuros()
{
return this.euros;
}
// -----------------
public void sacarEuros( double euros )
{
this.euros -= euros;
}
// -----------------
public void ingresarEuros( double euros )
{
this.euros += euros;
}
}
Al ejecutarlo obtendríamos como resultado:
EXPLICACIÓN:
- La clase CajaEuros contiene los métodos necesarios para ingresar y sacar fondos en euros.
- Creamos una interface que define los métodos que implementará el objeto de tipo Adaptador, mediante los cuales éste redirigirá la comunicación hacia el objeto que gestiona la caja en euros (realizando previamente la conversión de pesetas a euros).
- Al inicio del programa se crea un objeto de tipo Adaptador, realizándose unos ingresos en pesetas y obteniendo luego el saldo en euros.
A continuación mostramos otra forma de implementarlo usando herencia:
Main.java (Cliente según el diagrama anterior):
package estructurales.adapter.adapter02;
public class Main
{
public static void main(String[] args)
{
Adaptador conversor = new Adaptador();
conversor.ingresarPesetas( 2000 );
conversor.ingresarPesetas( 5000 );
conversor.ingresarPesetas( 1000 );
System.out.println( "Total euros: " + conversor.getTotalEuros() );
}
}
IAdaptador.java (Objetivo según el diagrama anterior):
package estructurales.adapter.adapter02;
public interface IAdaptador
{
public abstract void sacarPesetas( double pesetas );
public abstract void ingresarPesetas( double pesetas );
}
Adaptador.java:
package estructurales.adapter.adapter02;
public class Adaptador extends CajaEuros implements IAdaptador
{
public Adaptador() {
}
// ------------------
@Override
public void sacarPesetas( double pesetas )
{
double euros = pesetas / 166.386;
this.sacarEuros( euros );
}
// ------------------
@Override
public void ingresarPesetas( double pesetas )
{
double euros = pesetas / 166.386;
this.ingresarEuros( euros );
}
}
CajaEuros.java (Adaptable según el diagrama anterior):
package estructurales.adapter.adapter02;
public class CajaEuros
{
private double euros = 0;
// -----------------
public CajaEuros() {
}
// -----------------
public double getTotalEuros()
{
return this.euros;
}
// -----------------
public void sacarEuros( double euros )
{
this.euros -= euros;
}
// -----------------
public void ingresarEuros( double euros )
{
this.euros += euros;
}
}
El resultado obtenido sería el mismo que en el caso anterior.
EXPLICACIÓN:
- En este caso la clase Adaptador hereda de CajaEuros (en lugar de contener una referencia a un objeto de dicho tipo como en el ejemplo anterior), para así poder acceder directamente a sus métodos.
