Posts Tagged ‘patrones fundamentales

11
Sep
13

Delegation (Patrón de diseño)

Para cerrar la parte de patrones fundamentales, trataremos el patrón de delegación, este patrón ha sido descrito como una manera de realizar “herencia múltiple manualmente mediante composición de objetos”.

Delegation, se trata de una técnica en la que un objeto permite mostrar cierto método al exterior, pero internamente la implementación o las acciones desencadenadas por el llamado de este método se delega a otro objeto de una clase distinta pero asociado. La delegación es utilizada como un mecanismo para centralizar en torno a un solo objeto  los compartimentos(métodos) de varios objetos donde dichos comportamientos mantienen cierto nivel de relación.

 

 

Podemos implementar Delegation de dos maneras, (1) la primera es haciendo uso de objetos dentro de otro (composición) y (2) la otra manera es la utilización de interfaces; permitiendo que la implementación del patrón pueda ser realizada, sin embargo en ocasiones la relación deseada entre clases es de contención en vez de herencia. Delegation no se limita solo a escenarios donde se debe evitar la herencia múltiple (la herencia múltiple no es permitida en Java) , pero se puede ver como una alternativa general a la herencia.

Este patrón se usa comúnmente en casos donde:

  • Se desea reducir el acoplamiento de métodos para una clase.
  • Existen componentes que tienen comportamientos similares, pero que en un futuro es posible que se realicen cambios.
  • Se desea remplazar la herencia, generalmente se usa la delegación como alternativa a la herencia.

Hay que tener en cuenta que la herencia a pesar de ser una buena estrategia para ser utilizada cuando existe una estrecha relación entre las clases involucradas, no es recomendada cuando la relación no es tan estrecha, ya que se crea una lazo de dependencia directa entre las clases; por otra parte la delegación es la forma más flexible para expresar una relación entre clases.

 

Ejemplo con clases:

package ingenio.ds.examples.patrones;
public class Clases{
	public static void main(String args[]){
		System.out.println("Usando el SuperAutoMovil");
		SuperAutoMovil superAutoMovil= new SuperAutoMovil();
		System.out.println("-- Funciones de AutoMovil:");
		superAutoMovil.iniciarMotor();
		superAutoMovil.andar();
		
		System.out.println();
		System.out.println("-- Funciones de Subergible:");
		superAutoMovil.navegar();
		superAutoMovil.navegarMasProfundo();
		superAutoMovil.navegarMasSuperficial();
		
		System.out.println();
		System.out.println("-- Funciones de Helicoptero:");
		superAutoMovil.volar();
		superAutoMovil.volarMasAlto();
		superAutoMovil.volarMasBajo();
	}
}

class Barco{
	public void iniciarMotor(){
		System.out.println("Barco: iniciando motor");
	}
	public void andar(){
		System.out.println("Barco: andando");
	}
}

class Automovil{
	public void iniciarMotor(){
		System.out.println("Automovil: iniciando motor");
	}
	public void andar(){
		System.out.println("Automovil: andando");
	}
}

class Helicoptero {
	public void iniciarMotor(){
		System.out.println("Helicoptero: iniciando motor");
	}
	public void andar(){
		System.out.println("Helicoptero: andando");
	}
	public void descender(){
		System.out.println("Helicoptero: descendiendo");
	}	
	public void ascender(){
		System.out.println("Helicoptero: ascendinedo");
	}
}

class Subergible extends Barco{
	public void descender(){
		System.out.println("Subergible: descendiendo");
	}	
	public void ascender(){
		System.out.println("Subergible: ascendinedo");
	}
}


class SuperAutoMovil extends Automovil{
	private Subergible  sumergible;
	private Helicoptero helicoptero;
	
	public SuperAutoMovil(){
		sumergible =new Subergible ();
		helicoptero=new Helicoptero();
	}
	
	public void andar(){
		super.iniciarMotor();
		super.andar();
	}
	
	public void navegar(){
		sumergible.iniciarMotor();
		sumergible.andar();
	}
	
	public void volar(){
		helicoptero.iniciarMotor();
		helicoptero.andar();
	}
	
	public void volarMasAlto(){
		helicoptero.ascender();
	}
	
	public void volarMasBajo(){
		helicoptero.descender();
	}
	
	public void navegarMasSuperficial(){
		sumergible.ascender();
	}
	
	public void navegarMasProfundo(){
		sumergible.descender();
	}
}

 
Ejemplo con interfaces:

package ingenio.ds.examples.patrones;

public class Interfaces {
	public static void main(String args[]) {
		Automovil automovil = new Automovil();
		automovil.andar();
		automovil.setMotor(new MotorElectrico());
		automovil.andar();
	}
}

interface Motor{
	public void andar();
}

class MotorVapor implements Motor {
	public void andar() {
		System.out.println("Aumenta persión");
		System.out.println("Aumenta velocidad");
	}
}

class MotorElectrico implements Motor {
	public void andar() {
		System.out.println("Aumenta revoluviones");
		System.out.println("Aumenta velocidad");
	}
}

class  Automovil{
	private Motor motor = new MotorVapor();
	
	public void andar() {
		motor.andar();
	}
	
	public void setMotor(Motor motorNuevo) {
		motor = motorNuevo;
	}
}

 

06
Sep
13

Container (Patrón de diseño)

Container o patrón de contenedores, Un contenedor es un objeto creado para contener otros objetos  y permite agregar, acceder, modificar, eliminar, en otras palabras, un contenedor debe almacenar otros objetos y permitir su gestión a través de los métodos proporcionados por la clase contenedora [en java ya existe la API Collections que describe una serie de contenedores] – colas, pilas, listas, vectores. Estos objetos (los elementos contenidos) por lo general son de tipo Object, y por herencia pueden ser de cualquier tipo  incluso pueden ser de la misma clase del contenedor. Cada Container debe implementar algún tipo de iterador asociado para permitir recorrer los elementos contenidos.

El término contenedor en la programación informática moderna realidad puede referirse a muchas cosas:

  • Los programadores de Java, C# suelen llamar a este tipo de clases de “colecciones” en lugar de “contenedores”. la Java Collections Framework proporciona implementaciones para muchos tipos de clases Container, una implementación típica de una clase de colección en Java sería ArrayList o HashMap.
  • Dentro del Framework  Spring los contenedores representan conceptos de más alto nivel, tales como la inversión de control (IoC). una explicación (en inglés) de lo que es IoC e inyección de dependencias  Inversion of Control Containers and the Dependency Injection pattern [Martin Flower].
  • Beans Enterprise son componentes de software que se ejecutan en un entorno especial llamado un contenedor EJB. Los contenedores sirven de hots y gestionan un “enterprise bean” de la misma manera que el Java Web Server aloja un servlet o un navegador HTML alberga un applet de Java.

Los usos más comunes del patrón Container son:

  • Quiere representar un grupo de objetos como uno solo.
  • Desea reutilizar funcionalidades para almacenar diferentes tipos de objetos.

Todo el código está encapsulado en unsolo archivo java

package ingenio.ds.examples.patrones;

/*definición de la interfaz mensajero*/
package ingenio.ds.examples.patrones;
import java.util.Iterator;

public class Main {

    public static void main(String[] args) {
        // Contenedor de Integer
        Contenedor contenedorEntero = new Contenedor();
        contenedorEntero.agregar(1);
        contenedorEntero.agregar(2);
        contenedorEntero.agregar(3);

        //Contenedor de String, solo soporta objetos String
        //contenedorCadena.add(1); genera error de compilacion
        Contenedor contenedorCadena = new Contenedor();
        contenedorCadena.agregar("uno");
        contenedorCadena.agregar("dos");
        contenedorCadena.agregar("tres");

        //Contenedor de Object, soporta objetos de cualquier clase
        Contenedor conetendorObject =new Contenedor();
        conetendorObject.agregar(new Integer(0));
        conetendorObject.agregar(new Double(0));
        conetendorObject.agregar(false);
        conetendorObject.agregar("String value");
        conetendorObject.agregar(0F);

       imprimir(contenedorEntero);
       imprimir(contenedorCadena);
       imprimir(conetendorObject);
    }

    public static void imprimir(Contenedor contenedor){
    	//Obtenemos el iterador
    	Iterator iterador = contenedor.iterador();
    	System.out.println("Container: ");
        while (iterador.hasNext()) {
        	Object elemento=iterador.next();
            System.out.println(elemento.getClass() +" - " + elemento);
        }
    }
}

class Contenedor {

	protected Nodo nodoInicial = null;
    protected Nodo nodoFinal = null;

    private class Nodo {
        private E elemento;
        Nodo siguiente = null;
        Nodo anterior = null;

        public Nodo(E elemento) {
            this.elemento = elemento;
        }
    }

    private class Iterador implements Iterator {
        protected Nodo nodoActual = nodoInicial;

		//retorna si tiene mas elemento
        public boolean hasNext() {
            return nodoActual != null;
        }

        //retorna el siguiente elemento
        public E next() {
            if (nodoActual == null) {
                return null;
            }
            E elemento = nodoActual.elemento;
            nodoActual = nodoActual.siguiente;
            return elemento;
        }

        //elimina el ultimo elelento retornado
        public void remove() {
            nodoActual.anterior.siguiente = nodoActual.siguiente;
            nodoActual.siguiente.anterior = nodoActual.anterior;
        }
    }

    public void agregar(E o) {
        if (nodoInicial == null) {
            nodoFinal = nodoInicial = new Nodo(o);
        } else {
            Nodo newnode = new Nodo(o);
            newnode.anterior = nodoFinal;
            nodoFinal = nodoFinal.siguiente = newnode;
        }
    }

    public Iterator iterador() {
        return new Iterador();
    }
}
09
May
13

Interface (Patrón de diseño)

Una interfaz se define como una “Conexión física y funcional entre dos aparatos o sistemas independientes” [Rae 2013], esta describe las operaciones (la cara al mundo) que una entidad puede realizar, de igual manera establece los limites, niveles de acceso y la manera en que se desarrolla la comunicación entre dos entidades, para nuestro caso caso dos piezas de software. Por lo general, se refiere a una abstracción que proporciona un activo de sí mismo a la parte exterior.

 

La idea principal de una interfaz es separar las funciones (firma de métodos) de las implementaciones (cuerpo del método) . Cualquier solicitud que coincida con la firma de la interfaz de un objeto también puede ser enviada a ese objeto, independientemente de su aplicación. Restando importancia a cual clase realiza la implementación y responda el llamado ya que el llamado se hace sobre la interfaz, brindando la capacidad de poder intercambiar fácilmente la clase que implementa la interfaz sin modificar el código donde se hace el llamado a dicha interfaz.

 

 

El concepto de una interfaz es fundamental en la mayoría de los lenguajes de programación orientados a objetos. En algunos, los objetos son conocidos sólo a través de sus interfaces de modo que no hay manera de acceder a un objeto sin tener que ir a través de su interfaz.

 

Los usos más comunes para las interfaces son:

  • Deseamos describir la el protocolo de comunicación de una clase fuera de su paquete.
  • Se debe cambiar la implementación de una funcionalidad en tiempo de ejecución.
  • Durante el diseño desconocemos cual será la implementación que se usará en tiempo de compilación.

 
Interfaces.java

package ingenio.ds.examples.patrones;

/*definición de la interfaz mensajero*/
interface Mensajero{
	/*definición del método enviar*/
	public void enviar(String titulo,String mensaje);
}

Clases.java

package ingenio.ds.examples.patrones;
import javax.swing.JOptionPane;

class Consola implements Mensajero{
	public void enviar(String titulo,String mensaje){
		System.out.println("Log : "+mensaje);
	}
}

class Popup implements Mensajero{
	public void enviar(String titulo,String mensaje){
		JOptionPane.showMessageDialog(null,
									 mensaje,
									 titulo,
									 JOptionPane.INFORMATION_MESSAGE);
	}
}

Main.java

package ingenio.ds.examples.patrones;

public class Main {
	/*describe el tipo de mensaje que usaremos*/
	public static String TIPO_MENSAJE="CONSOLA";
	public static void main(String argumentos[]){
		/*en este punto no conocemos la implementación que se usará para enviar el mensaje*/
		Mensajero mensajero=getMensajero();
		/*llamamos el método enviar */
		mensajero.enviar("Hola","Iniciar envio de mensaje");
		mensajero=getMensajero();
		mensajero.enviar("Hola","Patrón interface");
		mensajero=getMensajero();
		mensajero.enviar("Hola","Cerrar envio de mensaje");
	}

	public static Mensajero getMensajero(){
		/*dependiendo del 'contexto' retornará el mensajero necesario*/
		Mensajero mensajero=null;
		if(TIPO_MENSAJE=="CONSOLA"){
			mensajero=new Consola();
			TIPO_MENSAJE="POPUP";
		}else{
			mensajero=new Popup();
			TIPO_MENSAJE="CONSOLA";
		}
		return mensajero;
	}
}
07
May
13

Patrones Fundamentales

Son uno de los tipos de patrones de diseño. Se denominan fundamental, ya que contemplan funcionalidades básicas para los otros patrones, la mayoría de los las aplicaciones de los demás patrones se diseñan utilizando como base estos patrones de una manera u otra.

Algunos de los patrones fundamentales son trasladados a otras categorías: Proxy, Facade, Composite son ejemplo de ello. Mientras otros son incluidos dentro de las características propias de los lenguajes de programación por ejemplo la Collection en Java tiene varias implementaciones del patrón Container, a su vez el patrón Interface siempre ha estado vinculado a la Java desde su nacimiento. Se hace importante mantener la referencia de lo que en algún momento se reconoció como un patrón de diseño.

Interface: es un tipo especial de clase que le brinda al programador una manera más sencilla y específica de acceder a los atributos o funcionalidades de otras clases (entendiendo por interface como la cara accesible de una clase). En Java la implementación de este patrón es implícita en el uso del lenguaje, ya que sin “necesidad” de especificarlo el lenguaje se basa en sus interfaces para exponer la funcionalidad de una clase con el mundo exterior, y esto es una parte fundamental del lenguaje. A diferencia de C++, que tiene los archivos de cabecera para poder presentar la interfaz de una clase al exterior.

Container: es un objeto que nos permite agrupar múltiples elementos en una sola unidad, y al mismo tiempo brindando funcionalidades que nos permitan almacenar, recuperar, manipular, eliminar y comunicarnos con los datos agregados.  en Java contamos con la Java Collection Framework que es una arquitectura unificada para representar y manipular colecciones. Todos los frameworks de colecciones  contienen interfaces, implementaciones y algoritmos.

Delegation: este patrón permite la extensión de la funcionalidad de una clase a través de el uso de una clase contenedora que almacena a la clase original,así proporcionar las funcionalidades de la clase contenida a través del contenedor. Algunos autores lo describen como “Herencia realizada manualmente”   permitiendo a lenguajes como Java (que solo permiten herencia simple) simular la figura de herencia múltiple.

07
May
13

Patrones de diseño

En la ingeniería de software frecuentemente nos encontramos con problemas a nivel de desarrollo, que tal vez son escalado de una de las etapas anteriores. Muchos de estos problemas ya han sido solucionados en estrategias que gracias a su capacidad de implementarse en diferentes sistemas se convierten en patrones. Estos patrones los podemos definir como: “Los patrones de diseño son el esqueleto de las soluciones a problemas comunes en el desarrollo de software.” (¿Qué es un Patrón de Diseño?);     de igual manera los podemos definir como: modelo de objeto re-utilizable que ha sido útil en más de un contexto practico, brindando una solución a un problema en común.

En otras palabras los patrones son modelos que ha solucionado un problema en diferentes sistemas entonces se estandariza y brinda la posibilidad de replicar el mismo modelo para solucionar dicho problema en otro sistema independiente al contexto de este; se utiliza la palabra modelo ya que no todos los patrones son fácilmente adaptables a código. En los patrones se describe una plantilla (esqueleto) para resolver el problema, la destreza del programador tiene un papel fundamental para determinar el cuando y el como utilizarlos, ademas que ningún patrón es la piedra angular (no debes siempre utilizar el mismo) al momento de solucionar un problema, ya que en la practica un solo sistema puede utilizar varios patrones.

Para poder entender e implementar patrones en su plena concepción se debe tener claro que es programación orientada a objetos y cuales son sus principales propiedades: clase, objeto, método, paso de mensajes, herencia, encapsulamiento, polimorfismo y abstracción (aquí algunas).

Los patrones de diseño se clasifican en cinco categorías:

  1. Fundamentales: estos son utilizados en otros patrones para cumplir con el propósito establecido.
      1. Interface
      2. Container
      3. Delegation

     

  2. Arquitectónicos: estos patrones expresan una organización fundamental de la estructura del sistema, de igual manera proporcionan un conjunto de subsistemas especificando sus responsabilidades, reglas, directrices y relaciones entre ellos.
    1. Modelo Vista Controlador (MVC)
    2. Inyección de Dependencias

     

  3. Estructurales: describen como las clases y objetos se relacionan entre sí para trabajar entre ellos.
    1. Facade
    2. Decorator
    3. Proxy
    4. Data Access Object
    5. Transfer Object
    6. Composite
    7. Adapter

     

  4. de Creación: Ellos ayudan a hacer un sistema independiente de cómo se crean los objetos, que clases puedo instancias o sobre que objetos delego dicha responsabilidad.
    1. Factory Method
    2. Abstract Factory
    3. Object Pool
    4. Singleton
    5. Builder

     

  5. de Comportamiento: Se relacionan con los algoritmos y la asignación de responsabilidades entre los objetos, organización, nos permiten definir la comunicación entre los objetos y la manera en la que fluye la información entre ellos..
    1. Iterator
    2. Observer
    3. Event Listener
    4. Strategy
    5. Chain of Responsability
    6. Command
    7. Interpreter
    8. Mediator
    9. Memento
    10. State
    11. Visitor
    12. Template Method

Los patrones no son reglas estrictas son guías aplicables a nuestros desarrollos, incluso no siempre han sido bien recibidos por las comunidades académicas  recibiendo fuertes criticas, Estos nacen como el esfuerzo pos estandarizar lo que ya conocemos como mejores practicas, y muchas veces la implementación de patrones se desencadena en una duplicación innecesaria de código, para brindar una solución a un problema que en realidad pudo ser resulto por una restructuración del código y “Peter Norvig ofrece un argumento similar. Él demuestra que 16 de los 23 patrones en el libro Patrones de diseño (que se centra principalmente en C++) se han simplificado o eliminado (a través de apoyo lenguaje directo) en Lisp o Dylan”.

Referencias




I+Ds

Dudas consultas
Facebook
Twiter
Google +

Escribe tu dirección de correo electrónico para suscribirte a este blog, y recibir notificaciones de nuevas publicaciones por correo.

Únete a otros 348 seguidores

Redes Sociales y Archivos

Entradas

junio 2017
L M X J V S D
« Abr    
 1234
567891011
12131415161718
19202122232425
2627282930  

IngenioDS en twiter


A %d blogueros les gusta esto: