Clasificación:
Patrón
Estructural.
Propósito:
Proporcionar una interfaz de alto
nivel, unificada a un conjunto de interfaces en un subsistema,
haciendo más fácil de usar todas aquellas, minimizando
las comunicaciones y dependencias entre el liente y los subsistemas.
También conocido como:
Facade.
Intención:
Su objetivo es reducir al
mínimo la comunicación y las dependencias entre los subsistemas;
una manera de lograr este objetivo es introducir un objeto que
proporciona la fachada de una sola interfaz simplificada a la más
general de las instalaciones de un subsistema.
Motivación :
Estructurar un sistema en subsistemas
ayudando a reducir la complejidad, estructurando un entorno de
programación.
Aplicabilidad:
Proporciona una interfaz sencilla a un subsistema
complejo, – a medida que un subsistema evoluciona va teniendo más clases,
más pequeñas, más flexibles y configurables, – existen clientes que
no necesitan tanta flexibilidad y que quieren una visión más simple del
subsistema ,– sólo los clientes que necesiten detalles de más bajo nivel
accederán a las clases detrás de la fachada, puesto que cuando hay muchas
dependencias entre los clientes y las clases de implementación de una
abstracción es cuando la fachada desacopla el subsistema de los clientes y de
otros subsistemas, mejorando la independencia de subsistemas y la
portabilidad.
Para estructurar un sistema en capas –la fachada
define el punto de entrada de cada nivel, – se pueden simplificar las
dependencias obligando a los subsistemas a comunicarse únicamente a través
de sus fachadas.
Estructura :
Los participantes:
- Facade:
Conoce qué clases son responsables de
las peticiones y así, delega las peticiones a los
objetos apropiados.
- Subsystem:
Implementa la funcionalidad
del subsistema, realiza el trabajo solicitado por el objeto
Façade y no
conoce, ni mantiene referencia alguna del objeto mismo Facade.
Colaboraciones:
Los clientes se comunican con el subsistema haciendo
peticiones a la Fachada, que las envía a los objetos del subsistema
apropiados (la fachada podría también traducir su interfaz a la de las
interfaces del subsistema), de modo que los clientes que usan la fachada no
tienen que acceder a los objetos del subsistema directamente.
Consecuencias:
Oculta a los clientes los componentes del subsistema,
reduciendo el número de objetos con los que tienen que tratar los
clientes.
Disminuye el acoplamiento entre un subsistema y sus
clientes, un menor acoplamiento facilita el cambio de los componentes del
subsistema sin afectar a sus clientes –
Las fachadas permiten estructurar el sistema en capas,
reduciendo las dependencias de compilación. No evita que las aplicaciones
puedan usar las clases del subsistema si lo necesitan, eligiendo
entre facilidad de uso y generalidad.
El
acoplamiento débil permite variar los componentes del subsistema, sin que
ello afecte a sus clientes.
La reducción
de las dependencias de compilación es de vital importancia en los grandes
sistemas de software.
Una fachada
también puede simplificar los sistemas de portar a otras plataformas, ya
que es menos probable que la
construcción de un subsistema requiere de la construcción todos los demás.
Implementación:
package
logica;
public class
Fachada {
public String activarAire()
{
AireAcondicionadoCarro aire = new AireAcondicionadoCarro();
aire.activarAire();
return aire.getEstadoAlarma();
}
public String activarLuces()
{
LucesCarro luces = new LucesCarro();
luces.encenderLuces();
return luces.getEstadoLuces();
}
public String activarAlarma()
{
AlarmaCarro alarma = new AlarmaCarro();
alarma.activarAlarma();
return alarma.getEstadoAlarma();
}
}
package
logica;
public class
AlarmaCarro {
private String estadoAlarma;
public void activarAlarma()
{
estadoAlarma= "Se ha activado la alarma";
}
public void desactivarAlarma()
{
estadoAlarma = "Se ha desactivado la alarma";
}
public String getEstadoAlarma()
{
return estadoAlarma;
}
package
logica;
public class
AireAcondicionadoCarro {
private String estadoAire;
public void activarAire()
{
estadoAire = "Aire acondicionado encendido";
}
public String getEstadoAlarma()
{
return estadoAire;
}
}
package
logica;
public class
LucesCarro
{
private String estadoLuces;
public void encenderLuces()
{ estadoLuces = "Se han encendido las luces";
}
public String getEstadoLuces()
{
return estadoLuces;
}
}
package
interfaz;
import
logica.Fachada;
import
java.awt.event.ActionEvent;
import
java.awt.event.ActionListener;
import
java.awt.event.WindowAdapter;
import
java.awt.event.WindowEvent;
import
javax.swing.JButton;
import
javax.swing.JFrame;
import
javax.swing.JTextArea;
public class
Conductor extends JFrame implements ActionListener{
private Fachada facha;
private Conductor conduc;
private JButton encenderAire;
private JButton activarAlarma;
private JTextArea txtArea;
public Conductor(){
this.setSize(400,500);
this.setLayout(null);
this.setDefaultCloseOperation(Conductor.DISPOSE_ON_CLOSE);
this.setTitle(":::Carro:::");
txtArea = new JTextArea();
txtArea.setSize(350, 250);
txtArea.setLocation(10, 10);
txtArea.setText("");
txtArea.setEditable(false);
add(txtArea);
encenderAire = new JButton();
encenderAire.setSize(150, 50);
encenderAire.setLocation(50, 300);
encenderAire.setText("Aire Acondicionado
Encendido");
this.getContentPane().add(encenderAire);
encenderAire.addActionListener(this);
activarAlarma = new JButton();
activarAlarma.setSize(150, 50);
activarAlarma.setLocation(50, 350);
activarAlarma.setText("Alarma Encendida");
this.getContentPane().add(activarAlarma);
activarAlarma.addActionListener(this);
addWindowListener(new Cierre());
facha = new Fachada();
}
public void actionPerformed(ActionEvent e) {
if (e.getSource() == encenderAire) {
txtArea.setText(facha.activarAire());
}
if (e.getSource() == activarAlarma)
{
txtArea.setText(facha.activarAlarma());
}
}
class Cierre extends WindowAdapter {
@Override
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
}
package
interfaz;
/**
*
*
@author Katherin
*/
public class
Main {
public static void main(String[] args) {
Conductor ventana=new Conductor();
ventana.setVisible(true);
}
}
Usos
conocidos:
ObjectWorks
\ Smalltalk compilador sistema. ET en el marco de aplicación + +
[WGM88], puede tener una aplicación incorporada en herramientas de
navegación para la inspección de sus objetos en tiempo de ejecución. Estas son
herramientas de navegación aplicado en un subsistema que incluye una
clase llamada Fachada "ProgrammingEnvironment". Esta fachada se
define como operaciones InspectObject y InspectClass para acceder a
los navegadores.
Las opciones
del sistema operativo [CIRM93] utiliza para componer muchas fachadas
marcos en uno. Las principales opciones son abstracciones en
procesos, almacenamiento, y la dirección espacios. Para cada una de
estas abstracciones hay un subsistema correspondiente, aplicarse
como un marco, que apoya a las opciones de portar una gran variedad
de plataformas de hardware. Dos de estos subsistemas tienen un
"representante" (es decir, la fachada). Estos
representantes son FileSystemInterface (almacenamiento) y de dominio
(dirección espacios).
Patrones
relacionados:
- Normalmente sólo hace falta un objeto Fachada, por lo cual suele implementarse como Singleton.
- Abstract Factory se puede utilizar con Fachada para proporcionar una interfaz para la creación de subsistema de objetos en un subsistema de manera independiente. Resumen de fábrica también se puede utilizarse como una alternativa a la fachada para ocultar las clases específicas de la plataforma.
- Mediator es similar a la fachada en el sentido de que la funcionalidad de los resúmenes clases. Sin embargo, el propósito del Mediador es arbitraria resumen de comunicación entre colega objetos, a menudo la centralización de la funcionalidad que no pertenece en cualquiera de ellos. Un mediador de colegas y son conscientes de comunicarse con el mediador en lugar de comunicarse unos con otros directamente. En contraste, un fachada simplemente resúmenes de la interfaz con el subsistema de objetos para que sean más fáciles a utilizar, pero no definir nuevas funciones, y las clases del subsistema no sabe sobre él.
Referencias:
PDF-Departamento de Sistemas Informáticos y
Programación Curso de doctorado 1999 - 2000 Patrones
de diseño orientado a objetos.
DesIgn Patterns: Elements of
Reusable Object-Oriented Software Gamma, Helm, Johnson,
Vlissides Editorial Addison-Wesley.
