Nuevos Programadores

Patrón Decorador - Definición, diagramas e implementación

Pablo — Wed, 19 Nov 2008 05:16:57 +0000

El patrón decorador, (decorator pattern), añade nuevas responsabilidades a un objeto dinamicamente, ofreciendo una alternativa flexible a la herencia.

En otras palabras, es una forma de agregar funcionalidades a una clase, extendiéndola pero sin recurrir a la herencia. ¿Por qué no heredar? Bueno, tal vez no desees dar acceso a toda la clase primaria y entonces sólo se daría acceso a lo necesario.

Veamos un ejemplo simple, tenemos las siguientes clases:

Persona (ID, Nombre, Apellido y Fecha de Nacimiento)
Usuario (ID, Nombre, Apellido, Usuario, Passwd)
Cliente (ID, Nombre, Apellido, Teléfono, Email)
Cliente VIP (ID, Nombre, Apellido, Teléfono, Email, Nro de Cuenta, Límite de Crédito)

Cómo vemos todos tienen campos comunes a Persona, pero no tienen todos los campos de la clase Persona, por eso no podemos heredar, así es que podremos implementar decoradores para la clase Persona, tendremos los decoradores Usuario, Cliente y Cliente VIP. (Ver figura 1).

Pero si analizamos lo que hemos diseñado hasta el momento podremos observar que Cliente VIP podría llegar a convertirse en un decorador de Cliente, que como recordamos es un decorador de Persona, de esa manera no tendremos que reescribir la lógica detrás de los atributos Teléfono e Email. (Ver figura 2).

La pregunta es cómo decorar una clase, pues a grandes rasgos podríamos decir que se trata de tener una variable privada de la clase a decorar, escribir los métodos o atributos que se deseen publicar de la clase a decorar y luego agregar las decoraciones en nuestra nueva clase, entendiendo por decoraciones los nuevos métodos y/o atributos.

Por último veamos el código correspondiente a nuestras clases.



class Persona
{
	private int ID;
	private String Nombre;
	private String Apellido;
	private Date FechaNac;
 
	public int getID()
	{
		return ID;
	}
 
	public String getNombre()
	{
		return Nombre;
	}
 
	public String getApellido()
	{
		return Apellido;
	}
 
	public Date getFechaNac()
	{
		return FechaNac;
	}
}
 
class Usuario
{
	private Persona mPersona;
 
	private String Usuario;
	private String Passwd;
 
	public int getID()
	{
		return mPersona.getID();
	}
 
	public String getNombre()
	{
		return mPersona.getNombre();
	}
 
	public String getApellido()
	{
		return mPersona.getApellido();
	}
 
	public String getUsuario()
	{
		return Usuario;
	}
 
	public String getPasswd()
	{
		return Passwd;
	}
}
 
class Cliente
{
	private Persona mPersona;
 
	private String Telefono;
	private String Email;
 
	public int getID()
	{
		return mPersona.getID();
	}
 
	public String getNombre()
	{
		return mPersona.getNombre();
	}
 
	public String getApellido()
	{
		return mPersona.getApellido();
	}
 
	public String getTelefono()
	{
		return Telefono;
	}
 
	public String getEmail()
	{
		return Email;
	}
}
 
class Cliente_VIP
{
	private Cliente mCliente;
 
	private String NroCuenta;
	private Double LimiteCredito;
 
	public int getID()
	{
		return mCliente.getID();
	}
 
	public String getNombre()
	{
		return mCliente.getNombre();
	}
 
	public String getApellido()
	{
		return mCliente.getApellido();
	}
 
	public String getTelefono()
	{
		return mCliente.getTelefono();
	}
 
	public String getEmail()
	{
		return mCliente.getEmail();
	}
 
	public String getNroCuenta()
	{
		return NroCuenta;
	}
 
	public Double getLimiteCredito()
	{
		return LimiteCredito;
	}
}

Python: Funciones que devuelven más de un valor

Pablo — Tue, 11 Nov 2008 01:41:19 +0000

Muchas veces nos encontramos con situaciones en las que nos vendría muy bien poder devolver más de un valor en una función… generalmente podemos recurrir a arrays, colecciones, diccionarios, hastables, etc. Pero en Python podemos devolver múltiples valores en una misma función y lo mejor de todo es que esos valores de retorno pueden ser de diferente tipo.

Dejo un par de ejemplos, escribo la función y luego la ejecuto para probar.



def masUnoMasDos(x):
     return x+1, x+2
 
print ""
print "masUnoMasDos()"
 
a,b = masUnoMasDos(7)
print "x+1 = "+str(a)
print "x+2 = "+str(b)
 
print "---------"
 
def rojo():
     return 255, 0, 0
 
print ""
print "rojo()"
 
print rojo()
 
print "---------"
 
def rojoHexa():
     return "ff", "00", "00"
 
print ""
print "rojoHexa()"
 
print rojoHexa()

Obtendremos la siguiente salida:

masUnoMasDos() x+1 = 8 x+2 = 9 ---------


rojo()

(255, 0, 0)

---------

rojoHexa() ('ff', '00', '00')

Para probar este código rápidamente, en caso de no tener Python instalado pueden utilizar http://codepad.org que es una excelente herramienta online, la misma permite compilar y ejecutar código en varios lenguajes, incluyendo: C/C++, D, Haskel, PHP, Pearl, Python y Ruby, entre otros.

ObsoleteAttribute - Para refactorear y mantener compatibilidad

Pablo — Tue, 04 Nov 2008 01:48:39 +0000

Algo muy común a la hora de refactorear es que se elimine algún método o alguna clase, pero si estamos trabajando en un grupo de soluciones con referencias entre ellas, eliminar un método puede causar bastantes problemas… y molestias en quienes estén trabajando con nuestro código.

.Net ofrece una ayuda, es un atributo que se puede aplicar a clases, métodos, propiedades, variables y constantes y que sirve de alternativa para no romper compatibilidad, el attributo Obsolete() nos permite marcar como obsoleta una porción del código sin eliminarlo y nos brinda la posibilidad de mostrar un mensaje y generar una advertencia o bien un error a la hora de compilar.

Veamos un pequeño ejemplo en VB.Net y luego en C#



Public Class MiClase
 
	("Este constructor fue reemplazado por New(String, Boolean)", True)> _
	Public Sub New(Arg1 as String, Arg2 as String)
		' Código del ctor obsoleto
		' Ahora genera un error al compilar
	End Sub
 
	Public Sub New(Arg1 as String, Arg2 as Boolean)
		'Código del nuevo ctor
	End Sub
 
	("Esta propiedad está obsolete. Por favor eliminar toda referencia a la misma antes del release 2.0")> _
	Public ReadOnly Property IsObsolete() As Boolean
		Get
			Return True
		End Get
	End Property
 
End Class



class Ejemplo
{
    [Obsolete()]
    public const string MI_CONSTANTE = "NuevosProgramadores.com";
 
    [Obsolete("No usar esta variable. Utilizar la variable FechaHoraActual en su lugar.", false)]
    DateTime Fecha = DateTime.Now;
 
}

A simple vista se puede ver que la única diferencia entre su uso en VB.net y C# es que los atributos se aplican de manera diferente.

Por último veamos las 3 firmas de este atributo:

Obsolete() - Genera una advertencia (warning) sin descripción alguna.
Obsolete(String) - Genera una advertencia con con la descripción indicada en el parámetro.
Obsolete(String, Boolean) - Utiliza el parámetro String como descripción y el Boolean indica si genera una advertencia (false) o un error (true).

Patrón Observador - Ejemplo en C#

Pablo — Thu, 30 Oct 2008 04:10:47 +0000

El patrón observador define una relación de uno a muchos, en la que un objeto único, al que llamaremos observable deberá notificar cada vez que cambie de estado a muchos objetos, que llamaremos observadores.

El funcionamiento de este patrón de diseño puede compararse con el de una suscripción a una revista, ya que los observadores se suscriben y cada vez que la revista, (observable), se actualiza, la misma se envía a los observadores suscriptos.

La definición del patrón observador es la siguiente: define una dependencia entre objetos de uno a muchos, de manera tal que cuando un objeto cambia su estado, todos sus dependientes son notificados y actualizados automaticamente.

Para demostrar el uso de este patrón, se ha creado un ejemplo en el que tenemos un form principal que tiene 2 botones, uno para abrir múltiples instancias de observadores, que en nuestro caso serán forms que mostrarán un listado desde una fuente de datos, un archivo XML más concretamente; y otro botón para abrir nuestro simulador de edición, que no es más que un form que nos permitirá editar la fuente de datos y nos permitirá observar que cada vez que alteramos los datos nuestros observadores serán notificados y actualizados automáticamente.

Es importante destacar que para una correcta implementación del patrón se utilizan interfaces que definen el rol de una clase como Observable u Observador, con lo cual nos olvidamos, por ejemplo de cómo se comporta cada clase cuando es notificada de un cambio de estado.

Veamos el diagrama de clases y a continuación el enlace para descargar nuestra mini-aplicación que implementa el patrón observador en C#.

Ejemplo de Patrón Observador en C# (155.92 KB)

Mover todos los archivos encontrados a un directorio en la consola de Linux

Pablo — Tue, 14 Oct 2008 00:18:17 +0000

Hoy alguien me preguntaba como mover todos los archivos encontrados en uno o más directorios usando el comando find y tenía una idea de como hacerlo, pero no tenía una máquina con Linux para probarla, en realidad es algo muy simple, en este caso moveremos todas las fotos encontradas en /home/nuevosprogramadores y todos sus subdirectorios a una nueva ubicación en /home/nuevosprogramadores/fotos y lo haremos con una sola línea.



$ mv `find /home/nuevosprogramadores -iname *.jpg ` /home/nuevosprogramadores/fotos

Ahora vamos a identificar las partes de ésta línea, primero el comando mv que se encarga de mover ficheros:



$ mv origen destino

ahora el comando find, tal cual lo usamos:



$ find directorio-origen -iname nombre-archivo

Lo que hicimos fue concatenar ambos comandos, utilizando la salida del comando find como entrada del comando mv, para lo cual encerramos al comando find con las comillas simples: “ resumiendo, nuestro comando sería:



$ mv `find directorio-origen -iname nombre-archivo` destino

Una aclaración más, el parámetro iname se utiliza para buscar por nombre ignorando mayúsculas y minúsculas.

Posts aleatorios

Head First Design Patterns - Aprendiendo Patrones de Diseño

Pablo — Fri, 03 Oct 2008 04:30:47 +0000

Me acaba de llegar el libro Head First Design Patterns, el segundo de la serie Head First de O’Reilly que tengo en mi poder, (el primero es Head First C#).

Vi este libro hace un tiempo y lo empecé a leer, después de leer el patrón estrategia, decidí que tenía que comprar este libro, por lo que de ahora en adelante postearé los conocimientos que vaya obteniendo acerca de Patrones de Diseño.

El libro trae ejemplos en Java, pero yo voy a intentar crear mis propios ejemplos y en más de un lenguaje!

Convertir un entero base 10 a binario en Java (Recursivo)

Pablo — Thu, 25 Sep 2008 05:41:35 +0000

En este ejemplo tenemos una aplicación simple que pide un número y lo convierte a binario utilizando un algoritmo recursivo con una variable externa.

Lo primero que tenemos que saber es cómo convertir un número de base 10 a binario, (base 2). Para ello, se divide el número deseado entre 2 y cada resultado de la división tantas veces como sea necesario hasta obtener el número indivisible, el 1. Luego se toman el último resultado, 1 y todos los restos de las divisiones, viendo la imagen va a quedar mucho más claro el concepto.

A continuación veremos el código en Java necesario para pedir el número en base 10 y devolverlo en binario, por supuesto que se pueden agregar validaciones, de hecho hay que agregar validaciones para asegurarnos que el usuario ingrese un número, pero ese no es el objetivo de este post.



import java.io.BufferedReader;
import java.io.InputStreamReader;
 
class binario
{
	public static void main(String[] args)
	{
		InputStreamReader isr = new InputStreamReader(System.in);
		BufferedReader rdr = new BufferedReader(isr);
		System.out.print("Ingrese un número entero: ");
		String buffer = "0";
		try
		{
			buffer = rdr.readLine();
		}
		catch(java.io.IOException e) // Es obligatorio manejar la IOException, si se omite no compila
		{
			System.out.println(e);
		}
 
		int dec = Integer.parseInt(buffer);
		System.out.print("El valor binario correspondiente es: ");
 
		if(dec == 0)
			System.out.println(dec); // Cero en cualquier base es cero
		else
			System.out.println(obtenerBinario(dec)); // llamamos a la func. recursiva
	}
 
 
	static String aux = ""; // variable auxiliar utilizada para almacenar el resto de cada división
 
	static String obtenerBinario(int decimal)
	{
		if(decimal == 1) // Límite de la recursividad
			return Integer.toString(decimal) + aux; // Devolvemos 1 y los restos anteriores
		else
		{
			aux = aux + Integer.toString(decimal % 2); //guardamos el resto en la variable auxiliar
			return obtenerBinario(decimal / 2); // hacemos el llamado recursivo con el resultado de la división
		}
	}
}

Además del algoritmo para convertir los números, vale la pena ver la forma en que se lee la entrada estándar, utilizando un BufferedReader, pero eso lo veremos con mayor profundidad en otro post.

Patrón Estrategia: Definición y ejemplo en Java

Pablo — Thu, 18 Sep 2008 06:34:26 +0000

El patrón Estrategia (Strategy) define una familia de algoritmos, los encapsula y hace intercambiables. Permitiendo a cada algoritmo variar independientemente de los clientes que lo utilizan.

Se utiliza para encapsular aquellas partes del código que varían, haciendo que éstas variaciones no afecten al resto del código, evitando así consecuencias inesperadas y brindando a nuestro código una mayor flexibilidad.

Para ilustrarnos con un ejemplo, supongamos que tenemos un grupo de terminales las cuales tienen su propio método de entrada y salida de datos, por ej. teclado, monitor, mouse, etc.
Supongamos que en éste momento sólo tenemos 3 métodos de entrada y 2 de salida, pero sabemos que en el futuro se van a agregar más, por ello recurriremos al Patrón Estrategia para encapsular los métodos de entrada y salida, permitiéndonos en el futuro implementar las nuevas terminales con gran facilidad y sin afectar a las ya existentes.

Para encapsular los métodos de entrada recurriremos al uso de interfaces, crearemos una interface Entrada y una Salida, las cuales serán implementadas por cada método de entrada/salida de datos. A su vez, necesitamos tener varias terminales y poder agregar los nuevos tipos, para ello utilizaremos herencia, todas nuestras terminales heredarán de la superclase Terminal.

La clase Terminal tendrá una variable de instancia del tipo Entrada (interface) y una del tipo Salida (interface).
Además crearemos una clase por cáda método de entrada y salida las cuales implementarán la interface correspondiente. También podremos definir una clase, por ejemplo Monitor_TouchScreen que implemente ambas interfaces, por lo que podremos utilizarlo como método de entrada y salida.

En los diagramas vemos las interfaces Entrada y Salida con las clases que la implementan, y la superclase Terminal con sus subclases.

Ahora podemos ir un paso más allá y crear una Terminal Mutable, (qué nombre, no?), por ese nombre me refiero a una Terminal que pueda cambiar sus método de entrada y/o salida en tiempo de ejecución, lo cual suena mucho más complejo de lo que realmente es, ya que la única diferencia con las terminales que hemos creado hasta el momento es que en esta tendremos que definirnos un setter para el método de entrada y uno para el método de salida, mientras que el resto no varía.

Luego de descargar esta implementación en Java hay que ir al directorio bin/ y ejecutar java TestTerminales

Ejemplo de Patrón Estrategia en Java (7.72 KB)

Corte de Control - Algoritmo y Ejemplo en C#

Pablo — Wed, 17 Sep 2008 01:39:06 +0000

Un Corte de Control es un algoritmo muy usado a la hora de listar datos. Actualmente es más factible obtener los datos con una consulta SQL, pero el Corte de Control aún es una técnica válida.

Un Corte de Control se compone de 3 partes básicas: principio, cuerpo y fin, en pseudo código sería así:



while(i < cantidadElementos)
{
     principio; // inicializar variables y condiciones, obtener datos, etc.
 
     cuerpo; // recorrer los datos respetando la condición.
 
     fin; // mostrar los datos.
}

En nuestro ejemplo tendremos datos de alumnos y cursos, la estructura es como si fuese una base de datos, entonces nuestras tablas tendrían la siguiente estructura:

Alumnos		Cursos
ID	int	ID	int
IDCurso	int	Descripción	string
Nombre	string

Y nosotros necesitamos hacer un Corte de Control por ID de Cursos (criterio del corte) para listar los alumnos agrupados por curso, entonces el algoritmo se vería de la siguiente manera:



static void corteDeControl()
        {
            // -- principio del corte
            int i= 0; // variable utilizada para iterar en la lista de cursos
            int IDCursoAnterior = 0; // variable con la condición del corte
            Dictionary<int, List<alumno>> resultado = new Dictionary<int, List<alumno>>(); // resultado del corte
            Console.WriteLine("\n\nListado de alumnos por curso\n"); // imprimir encabezado
 
            // -- cuerpo del corte
            while (i < DS.Cursos.Count)
            {
                IDCursoAnterior = DS.Cursos[i].ID; // condición del corte
 
                while (i < DS.Cursos.Count && DS.Cursos[i].ID == IDCursoAnterior) // mientras se cumpla la condición del corte
                {
                    foreach (alumno a in DS.Alumnos) // buscar los alumnos que pertenezcan a ese curso
                    {
                        if (a.IDCurso == IDCursoAnterior)
                        {
                            if (resultado.ContainsKey(IDCursoAnterior))
                            {
                                resultado[IDCursoAnterior].Add(a);
                            }
                            else
                            {
                                List<alumno> lista = new List<alumno>();
                                lista.Add(a);
                                resultado.Add(IDCursoAnterior, lista);
                            }
                        }
                    }
                i++; // siguiente iteración
                }
            }
 
            //fin del corte
            imprimir(resultado); // mostrar el listado
        }

Resumiendo, en pseudo código, el cuerpo del corte de control se vería más o menos así:



while(i < cantidadElementos)
{
     IDAnterior = items[i]; // condición del corte
     while(i < cantidadElementos && IDActual = IDAnterior)
     {
          // proceso datos
     }
     i++;
}

Puedes descargar una solución de Visual Studio 2005 con el ejemplo (25.93 KB).

Aprendamos a usar Expresiones Regulares (parte 1)

Pablo — Wed, 10 Sep 2008 03:16:52 +0000

Una expresión regular es un conjunto de caracteres y símbolos que definen una cadena según un patrón y no por sus elementos; por ejemplo, si queremos representar una cadena de caracteres que sólo puede estar formada por las letras a, b, c y los números del 1 al 3, utilizaremos el siguiente patrón: ^([a,b,c,1,2,3]+)$.

Ahora veamos los signos básicos en las expresiones regulares y su significado:

^	Inicio de la cadena
$	Fin de la cadena
[]	Cualquier caracter del conjunto, por ejemplo `[xyz]` representa el conjunto formado por las letras x,y,z y encontrará cualquiera de esos caracteres.
[^]	Cualquier caracter no incluido en el conjunto, por ejemplo`[^xyz]` representa cualquier caracter no incluido en el conjunto formado por las letras x,y,z
?	Cero o una ocurrencia de lo que precede al símbolo, por ejemplo para encontrar cero o una ocurrencia de www. utilizaremos el patrón `(www\.)?`
+	El caracter que le precede debe aparecer al menos una vez, por ejemplo Google, Gooogle, Gooooooogle se representa con la siguiente expresión regular: `Goo+gle`
*	El caracter que le precede debe aparecer cero, una o más veces, utilizando el ejemplo anterior, `Gooo*gle` representa Google, Goooogle, Goooooogle.
{x}	x ocurrencias del caracter que lo precede, por ejemplo www. podría ser representado con el patrón `w{3}\.`
{x,z}	Entre x y z ocurrencias del caracter que lo precede, con el ejemplo de Google, si quisiéramos que hubieran mínimo 2 letras o y máximo 5, utilizaríamos el patrón `Go{2,5}gle`
{x,}	x o más ocurrencias de lo que lo precede, con el ejemplo de Google, para tener 2 o más letras o usaríamos la expresión regular `Go{2,}gle`

Esos son los signos básicos de las expresiones regulares, también tenemos la barra invertida, que se utiliza como caracter de escape en ciertos casos, cuando se desea incuir un caracter especial como ., * o ?, y para definir tipos de caracteres en otros, vemos algunos casos.

\.	Un punto dentro del patrón, como definimos en uno de los ejemplos anteriores, la expresión `w{3}\.` define la cadena www.
\s	Representa un espacio en blanco
\d	Un dígito numérico
\w	Un caracter alfanumérico
\n	Un salto de línea
\r	Representa el caracter de retorno de carro
\t	Tabulador
\S	Cualquier caracter excepto un espacio en blanco
\D	Cualquier caracter excepto un dígito numérico
\W	Representa cualquier caracter no alfanumérico

Esta es una introducción muy básica al uso de expresiones regulares, simplemente hemos visto algunos de los signos más básicos, en la próxima parte de este artículos veremos como crear algunas expresiones un poco más complejas. Mientras tanto pueden ir probando algunas expresiones en regexpal.com, un intérprete online de expresiones regulares.

Nuevos Programadores

Patrón Decorador - Definición, diagramas e implementación

También te puede interesar:

Python: Funciones que devuelven más de un valor

También te puede interesar:

ObsoleteAttribute - Para refactorear y mantener compatibilidad

También te puede interesar:

Patrón Observador - Ejemplo en C#

También te puede interesar:

Mover todos los archivos encontrados a un directorio en la consola de Linux

Posts aleatorios

Head First Design Patterns - Aprendiendo Patrones de Diseño

También te puede interesar:

Convertir un entero base 10 a binario en Java (Recursivo)

También te puede interesar:

Patrón Estrategia: Definición y ejemplo en Java

También te puede interesar:

Corte de Control - Algoritmo y Ejemplo en C#

También te puede interesar:

Aprendamos a usar Expresiones Regulares (parte 1)

También te puede interesar: