Aplicación de patrones de diseño

Taller de Programación Orientada a Objetos 
Semana 9 

Incorporación de patrones de diseño en la implementación del proyecto.

Identificación de patrones de diseño

Programación Orientada a Objetos 
Semana 9 

Para esta semana el trabajo a entregar es un texto con diagramas que explique cuáles patrones se aprovechan en nuestro proyecto.

Algunas personas definen un patrón como una solución recurrente para un problema en un contexto. Primero, un contexto es el entorno, situación, o condiciones interrelacionadas dentro de las cuales existe algo. Segundo, un problema es una cuestión insatisfecha, algo que se necesita investigar y resolver. Un problema se puede especificar mediante un conjunto de causas y efectos. Normalmente un problema está restringido al contexto en el que ocurre. Finalmente, la solución se refiere a la respuesta al problema dentro de un contexto que ayuda a resolver las dificultades.

Entonces, si tenemos una solución a un problema en un contexto, ¿Será este un patrón? No necesariamente. También necesitamos asociar la característica de recurrencia con la definición de un patrón. Los patrones deberían comunicar soluciones de diseño a los desarrolladores que los leen y los utilizan. Como puedes ver, aunque el concepto de patrón es bastante simple, definir realmente el término es muy complejo.

Abstracción de patrones

Un patrón describe, con algún nivel de abstracción, una solución experta a un problema. Los patrones solucionan problemas que existen en muchos niveles de abstracción. Hay patrones que describen soluciones para todo, desde el análisis hasta el diseño y desde la arquitectura hasta la implementación.

Identificar un patrón

Se han manejado muchos proyectos J2EE en Sun Java Center, y, con el tiempo, se ha notado que ocurren problemas similares en todos estos proyectos. También se ha visto que han emergido soluciones similares para todos estos problemas. Aunque las estrategias de implementación variaran, las soluciones generales eran bastante similares.

Cuando se ha visto un problema y una solución recurrentes, se ha intentado identificar y documentar sus características usando la plantilla de patrón. También se emprendió el procesamiento de significado de los patrones buscando patrones en soluciones ya implementadas.

Muchas veces, soluciones similares podrían representar un sólo patrón. Cuando se decide cómo formar un patrón, es importante considerar cual es la mejor forma de comunicar la solución. Algunas veces, un nombre independiente mejora la comunicación entre los desarrolladores. Si es así, es mejor considerar la documentación de dos soluciones similares como dos patrones diferentes.

Existen tres categorías de patrones de diseño de acuerdo a su propósito, y son los siguientes:

Creacionales: Inicialización y configuración de objetos.

Estructurales: Separan la interfaz de la implementación. Se ocupan de cómo las clases y objetos se agrupan, para formar estructuras más grandes.

Comportamiento: Más que describir objetos o clases, describen la comunicación entre ellos.

En cuanto a mi proyecto muestro cuales patrones creo que me servirían implementar y les explico el porque creo que me ayudan de alguna forma.

Patrón creacional: Builder

El patrón Builder es usado para permitir la creación de una variedad de objetos complejos desde un objeto fuente, el objeto fuente se compone de una variedad de partes que contribuyen individualmente a la creación de cada objeto complejo a través de un conjunto de llamadas a interfaces comunes de la clase Abstract Builder.

Abstrae el proceso de creación de un objeto complejo, centralizando dicho proceso en un único punto, de tal forma que el mismo proceso de construcción pueda crear representaciones diferentes.

Diagrama de ejemplo:

Algunas ventajas:

• Varia la representación interna de estructuras compleja, respetando la interfaz común.
• Se independiza el código de construcción de la representación.
• Evita el acoplamiento.
• Cada ConcreteBuilder tiene el código especifico para crear y modificar una estructura interna concreta.
• Permite un mayor control en el proceso de creación del objeto.

¿Porqué creo se aplica a mi proyecto?
En mi proyecto cada clase se encarga de crear un objeto diferente, por ejemplo una crea la ventana con ciertas opciones, la clase de registro muestra en un label un cuadro con la información almacenada en los registros guardados, otro crea una gráfica y la inserta en un label que remplazaría al de registros.

Patrón estructural: Composite

El patrón Composite describe un grupo de objetos deben ser tratados de la misma manera que una sola instancia de un objeto. La intención de un compuesto es la de "componer" objetos en estructuras de árbol para representar jerarquías parte-todo. Aplicación del modelo compuesto permite a los clientes tratar objetos individuales y composiciones de manera uniforme

Composite puede ser utilizado cuando los clientes deben pasar por alto la diferencia entre las composiciones de objetos y objetos individuales. Si los programadores encuentran que están utilizando varios objetos de la misma manera, y con frecuencia tienen casi idéntico código para manejar cada uno de ellos, entonces este patrón es una buena opción, es menos complejo en esta situación para tratar primitivos y compuestos como homogéneos.

Diagrama de ejemplo:

Patrón de comportamiento: Mediator

Un Mediator es un patrón de diseño que coordina las relaciones entre sus asociados. Permite la interacción de varios objetos, sin generar acoples fuertes en esas relaciones.

Cuando muchos objetos interactúan con otros objetos, se puede formar una estructura muy compleja, con objetos con muchas conexiones con otros objetos. En un caso extremo cada objeto puede conocer a todos los demás objetos. Para evitar esto el patrón Mediator encapsula el comportamiento de todo un conjunto de objetos en un solo objeto.

Usar el patrón Mediator cuando:
Un conjunto grande de objetos se comunica de una forma bien definida, pero compleja.
Reutilizar un objeto se hace difícil por que se relaciona con muchos objetos.
El comportamiento de muchos objetos que esta distribuido entre varias clases, puede resumirse en una o varias por subclasificación.

¿Porqué se aplica a mi proyecto?
Mi proyecto necesita la interacción entre clases para la creación de los objetos en una ventana, y para evitar sobrecargar el sistema este serviría para esto ya que evitaríamos tener que estar regresando a la clase principal para crear todos los objetos nuevamente, ya que por ejemplo en la clase Gráfica se crea la gráfica pero mi idea es no quitar de vista las opciones de la ventana mostrada anterior a esta.

Diagrama de ejemplo:

Ventajas y desventajas:
Simplifica la comunicación entre objetos: Los objetos que se comunican de la forma "muchos a muchos" puede ser remplazada por una forma "uno a muchos" que es menos compleja y más elegante.
Abstrae como los objetos cooperan: Haciendo a la mediación un concepto independiente y encapsulandolo en un objeto permite enfocar como los objetos interactúan. Esto ayuda a clarificar como los objetos se relacionan en un sistema.
Centraliza el control: El mediador es el que se encarga de comunicar a los colegas, este puede ser muy complejo, difícil de entender y modificar.

Bibliografía:
Patrones de diseño en Java
¿Qué es un patrón de diseño
Builder | Composite | Mediator

Demostración de avance parcial

Taller de Programación Orientada a Objetos 
Semana 8 

Para esta semana les muestro el avance que tengo en mi proyecto, les recuerdo que se trata de un programa que te permita crear gráficas con facilidad de ciertas bases de datos. Sinceramente no llevo muy avanzado mi proyecto, hasta el momento solo hace cosas mediante la terminal, y el aspecto gráfico que sin duda es de lo más importante dado a que se requiere visualizar gráficas, lo iré incorporando poco a poco.

Sigo manejando las clases Menu, Registro, Nuevo, Graficar, Barras, Histograma y Pastel. Donde Menu es la clase principal del programa.

En la siguiente imagen les muestro como están los archivos dentro del paquete proyecto:

Ahora desde el terminal compilare los archivos:

esteban@esteban:~/Documents$ javac proyecto/*.java

Y ahora podemos ver que ya se han creado los archivos .class para que java pueda interpretar el código.

Ejecutando el programa desde el terminal se vería algo así:

esteban@esteban:~/Documents$ java proyecto.Menu p

Me falta ponerle más opciones al menú y agregarle la edición a los parámetros de las gráficas, que pronto estaré agregando, mientras tanto solo es muestra de que ya se logra ingresar de una clase a la otra, y escribe algo en terminal para indicarnos que es lo que se debería de estar haciendo.

Les dejo unos fragmentos del código:

public class Menu {

 public Menu() {
  BufferedReader entrada = null;

  try {
   System.out.println("Seleccione una opcion:");
   Nuevo n = new Nuevo();
   Registro r = new Registro();

   System.out.println("Selecciona el registro
      que quieres graficar:");
   BufferedReader in = new BufferedReader(
     new InputStreamReader(System.in));
   String linea = in.readLine();
   int x = Integer.parseInt(linea);
   if (x == 1) {
    System.out.println("Seleccionado registro 1\n");
    Grafica gra = new Grafica();
    System.out.println("Deseas guardar la grafica: Si/No\n");
   }

  } catch (Exception e) {
   System.err.println("Error");
   System.exit(-1);
  } finally {
   if (entrada != null) {
    try {
        entrada.close();
    } catch (Exception ex) {}
   }
  }
 }

 public static void main(String[] args) {
  System.out.println("Esta es la ventana del Menu\n");

  Menu m = new Menu();

  System.out.println("Cerrar programa\n");

  return;
 }
}

Es la clase Menu, donde la función main crea el mismo Menu, y este es el que nos permitirá ver las opciones disponibles en la ventana principal del programa.

 public Nuevo() {
  try {
   FileWriter fw = new FileWriter("proyecto/nuevo.txt");
   BufferedWriter bw = new BufferedWriter(fw);
   PrintWriter salida = new PrintWriter(bw);
   salida.println("Esteban");
   salida.println("Cecilia");
   salida.println("Roberto");
   salida.println("Juan");
   salida.close();

   System.out.println("Se creo un nuevo archivo\n");
  } catch(java.io.IOException ioex) {
   System.out.println("Se presento el error: " +
    ioex.toString());
  }
 }

 public void agregarColumna() {
 }

 public void visualizar() {
 }

En esta clase Nuevo para un nuevo registro he hecho que el programa cree una lista de nombres simple pero desde el mismo programa, pero esa no es la idea, ya que el usuario es el que ira agregando esa información.

 public Registro() {
  System.out.println("Entra a Registro");
  System.out.println("Ver registros...\n");

  File archivo = null;
  FileReader fr = null;
  BufferedReader br = null;

  try {
   System.out.println("1. Registro de nombres");
   archivo = new File("proyecto/nuevo.txt");
   fr = new FileReader(archivo);
   br = new BufferedReader(fr);
   String linea;
   while((linea = br.readLine()) != null)
    System.out.println(linea);
  } catch(Exception e) {
   e.printStackTrace();
  }
 }

Nos lee los datos que están contenidos en el archivo creado por Nuevo, y es aquí donde se comprobará que bases de datos se tienen disponibles, y poder mostrarlas al usuario.

Es un tanto sencillo pero espero que vaya tomando forma.

Presentación de diagramas del proyecto

Programación Orientada a Objetos 
Semana 8 

Esta semana corresponde a la presentación de nuestros diagramas de proyecto, en el que se incluye el diagrama de clases y el diagrama de secuencia, que son los dos diagramas con los que trabajamos la semana anterior.

Les dejo mi presentación en un vídeo subido a YouTube, y abajo el enlace por si lo desean ver directamente en la página.

Ver directo en YouTube

Sin más por el momento, esto sería todo para esta semana en la clase de Programación Orientada a Objetos.

Código autogenerado y comparación

Taller de Programación Orientada a Objetos 
Semana 6 

Ahora es momento de mostrarles el código autogenerado a partir del diagrama de clases creado desde Umbrello que como ya mencione es el programa que decidí usar para la creación de diagramas UML.

En la entrada anterior lo que realicé fue generar el diagrama a partir del código que tenía hasta ese momento, ahora haré lo contrario, crear el diagrama de clases y a partir de ello que Umbrello me genere el código.

Esta captura es la ventana del programa donde cree mi diagrama de clases, muy parecido a lo que me resulto cuando genere el diagrama a partir del código.

Para generar el código, hay que asegurarnos de seleccionar el lenguaje al que deseamos crearlo. Para esto vamos al menú Code, en la opción Active Lenguage seleccionamos nuestro lenguaje en mi caso es Java.

Ahora en el mismo menú Code encontramos la opción para generar el código que es Code Generation Wizard.

Después se nos desplegará una ventana para seleccionar las clases que deseamos que se genere código.

Al dar en siguiente nos muestra una ventana como la siguiente donde podemos cambiar nuevamente el lenguaje en el que deseamos el código, así como la ubicación en donde serán guardados los archivos.

Por último se nos muestra en resumen las clases y el estado en que se encuentra cada una, es decir si ya se genero código o no. Para generarlo damos clic en Generate y listo.

Si vamos a la carpeta en donde decidimos que se guardaran los archivos con el código generado, encontraremos los archivos con extensión java, los cuales podemos abrir para observar el código tal y como lo genero Umbrello.

Aquí les dejo la imagen del diagrama de secuencia:

Para el diagrama de secuencia use una página web que te facilita la creación del mismo mediante líneas de código simple, aquí les dejo el enlace:
Web Sequence Diagrams

Aquí les dejo unas partes del código que genero Umbrello.

/**
 * Class Grafica
 */
public class Grafica extends Menu {

  //
  // Fields
  //
  
  //
  // Constructors
  //
  public Grafica () { };
  
  //
  // Methods
  //

  //
  // Accessor methods
  //

  //
  // Other methods
  //

  /**
   */
  public void obtenerDatos(  )
  {
  }

  /**
   */
  public void solicitarGrafica(  )
  {
  }

  /**
   */
  public void guardar(  )
  {
  }
}

/**
 * Class Histograma
 */
public class Histograma extends Grafica {

  //
  // Fields
  //

  private String xlabel;
  private String ylabel;
  private float rangox;
  
  //
  // Constructors
  //
  public Histograma () { };
  
  //
  // Methods
  //

  //
  // Accessor methods
  //

  /**
   * Set the value of xlabel
   * @param newVar the new value of xlabel
   */
  private void setXlabel ( String newVar ) {
    xlabel = newVar;
  }

  /**
   * Get the value of xlabel
   * @return the value of xlabel
   */
  private String getXlabel ( ) {
    return xlabel;
  }

  /**
   * Set the value of ylabel
   * @param newVar the new value of ylabel
   */
  private void setYlabel ( String newVar ) {
    ylabel = newVar;
  }

  /**
   * Get the value of ylabel
   * @return the value of ylabel
   */
  private String getYlabel ( ) {
    return ylabel;
  }

  /**
   * Set the value of rangox
   * @param newVar the new value of rangox
   */
  private void setRangox ( float newVar ) {
    rangox = newVar;
  }

  /**
   * Get the value of rangox
   * @return the value of rangox
   */
  private float getRangox ( ) {
    return rangox;
  }

  //
  // Other methods
  //

  /**
   */
  public void editar(  )
  {
  }

  /**
   */
  public void visualizar(  )
  {
  }
}

/**
 * Class Nuevo
 */
public class Nuevo extends Registro {

  //
  // Fields
  //
  
  //
  // Constructors
  //
  public Nuevo () { };
  
  //
  // Methods
  //

  //
  // Accessor methods
  //

  //
  // Other methods
  //

  /**
   */
  public void agregarColumna(  )
  {
  }

  /**
   */
  public void agregarFila(  )
  {
  }

  /**
   */
  public void verContenido(  )
  {
  }
}

No pongo todas las clases para no hacer mas extenso esto, así que solo deje tres de ellas.

Haciendo una comparación rápida con mi código no es tan diferente, solo que en la clase histograma no me agrado como genero algunas cosas del código, así como deja el lugar donde deberían de ir los métodos, etcétera. Aún y sean parecidos prefiero seguir con la base de mi propio código.

Si tienen alguna duda en como genere el código pueden preguntarme, o si tienen alguna sugerencia háganme saber.

Diagramas de clase y secuencia de UML

Programación Orientada a Objetos 
Semana 6 

Un diagrama de clase es un tipo de diagrama estático que describe la estructura de un sistema mostrando sus clases, atributos, y nos permite visualizar de forma clara las relaciones entre cada clase, así como no perder de vista sus métodos.

Recordando un poco que estoy trabajando en el desarrollo de un programa que permita crear gráficas de una forma fácil y más directa que con otros programas, pienso en una interfaz sencilla pero con suficientes opciones, por lo menos las básicas.

Diagrama de clases

El siguiente es mi diagrama de clases donde podemos ver la relación que existe entre clase y clase, tal y como ya se los venía comentando en entradas anteriores. Es más fácil identificar cual clase es heredera cosas de otra. Y como clase padre encontramos al Menú, que en primera instancia nos desplegará la ventana con unas cuantas opciones, como la de crear un nuevo registro, editarlo, visualizarlo, y a partir de ahí, generar una gráfica.

Diagrama de secuencia

El diagrama de secuencia es un tipo de diagrama usado para modelar interacción entre objetos en un sistema según UML.

En mi diagrama de secuencia, es posible ver precisamente la secuencia o camino que es recorrido a lo largo de la ejecución del programa desde que se muestra el menú, y lo que este desencadena. Creo que este diagrama muestra como sería lo que el usuario vería no tanto en la lógica del programa, ya que no vemos el proceso que implica, por ejemplo, crear un registro nuevo o el editar una gráfica, por decir algo.

El programa usado para la creación del diagrama de clases, fue Umbrello, esté es gratuito y es posible descargarlo e instalarlo desde el centro de software de Ubuntu, con tan solo buscar UML. Otro que también descargue fue BOUML que es de la misma utilidad, pero no lo use ya que Umbrello me pareció más fácil.

Para el diagrama de secuencia recurrí a una página web que te facilita la creación del mismo mediante líneas de código simple, aquí les dejo el enlace:
Web Sequence Diagrams

Otras referencias:
Definición de diagrama de clases
Definición de diagrama de secuencia