miércoles, 30 de marzo de 2011

Implementación de Patrones de Diseño (TALLER)

Bueno adjuntaré las líneas de código en las que considero están presentes los patrones de diseño Iterator y el Interpreter.

Patrón Iterator 

System.out.println("Lista de Inventario\n"); 
  Iterator iter = imprimir.list.iterator();                //recorrer la lista de nombres de productos guardados e imprimirlos
   while (iter.hasNext())
    System.out.println("Nombre: "+iter.next());
     
  Iterator itera = imprimir.listid.iterator();
   while (itera.hasNext())        //recorrer la lista de ID's guardados e imprimirlos
    System.out.println("ID: "+itera.next());
     
  Iterator iterac = imprimir.listcant.iterator();
   while (iterac.hasNext())       //recorrer la lista de cantidades de productos guardados e imprimirlos
    System.out.println("Cantidad Disponible: "+iterac.next());
     
  Iterator iteraci = imprimir.listprice.iterator();  //recorrer la lista de precios de productos guardados e imprimirlos
   while (iteraci.hasNext())       
    System.out.println("Precio Unitario: "+iteraci.next());
 }
  
} 

Aquí se muestran los iteradores recorriendo las estructuras de datos para ver si existe información alojada para después imprimir tal información.

----------------------------------------------------------------------------------------------------------------

Patrón Interpreter 

public class Product{
  
  
  
 public String Nombre;
 private int ID,Cantidad;                   //nombramos los atributos para agregar los productos
 private float Precio;
  
  
    List list = new ArrayList();             //generamos listas de los datos que queremos almacenar
   List listid = new ArrayList();         //en el inventario
   List listcant = new ArrayList();
   List listprice = new ArrayList();
     
  
     protected void ingproducto()    //metodo donde accedemos para ingresar productos
      {
     Integer ID = new Integer(0);       //creamos un objeto para guardar los datos de tipo entero
     Float Precio = new Float(0);       //creamos un objeto para guardar los datos de tipo flotante
      
     Scanner lectura = new Scanner(System.in);
      
         System.out.println ("Ingreso De Datos Del Producto");
         System.out.println ("=============================");         //menu de opciones para dar de alta un producto
         System.out.println ("Ingrese el Nombre del Producto-> ");
         Nombre = lectura.nextLine();  //guardar el nombre
         list.add(Nombre);     //agregarlo a la lista
         System.out.println ("Ingrese el ID del Producto-> ");
         ID = lectura.nextInt();   //guardar el ID
         listid.add(ID);       //agregarlo a la lista
         System.out.println ("Ingrese la Cantidad de Productos Disponibles-> ");
         Cantidad = lectura.nextInt();   //guardar la cantidad
         listcant.add(Cantidad);    //agregarlo a la lista
         System.out.println ("Ingrese el Precio Producto-> ");
         Precio = lectura.nextFloat();     //guardar el precio
         listprice.add(Precio);          //agregarlo a la lista
          
      }  
       
  }


Como sólo encontre en la API de java la declaración de listas para tipos de datos String, cree objetos que me permitieran guardar y leer tipos de datos enteros y flotantes, esto lo como un lenguaje especializado, ya que originalmente no estuvo declarado así.

Patrones de Diseño (CLASE)

Qué tal, en esta entrada les comentaré los patrones de diseño, que por lo que entendí, contiene o pueden ser implementados en mi proyecto.

Primero que nada definir lo qué es un patrón de diseño.

"Un patrón de diseño es una solución a un problema de diseño. Para que una solución sea considerada un patrón debe poseer ciertas características. Una de ellas es que debe haber comprobado su efectividad resolviendo problemas similares en ocasiones anteriores. Otra es que debe ser reusable, lo que significa que es aplicable a diferentes problemas de diseño en distintas circunstancias."


Ahora, en la siguiente imagen que es mi diagrama de clases, señale cuáles patrones de diseño considero pueden considerarse en mis clases.




Los patrones que identifique pueden ser o servir son el Iterator y el Interpreter.

Definidos por Wikipedia:
----------------------------------------------------------------------------------------------------------------------------------

"El patrón de diseño Iterador, define una interfaz que declara los métodos necesarios para acceder secuencialmente a un grupo de objetos de una colección. Algunos de los métodos que podemos definir en la interfaz Iterador son:
Primero(), Siguiente(), HayMas() y ElementoActual()

Este patrón de diseño permite recorrer una estructura de datos sin que sea necesario conocer la estructura interna de la misma.

En java por ejemplo:
"Un iterador es el recurso para recorrer colecciones. El iterador siempre conoce donde esta el próximo elemento. Algunos conocen donde está el elemento previo. O sea, que pueden reconocer la colección en ambos sentidos".
----------------------------------------------------------------------------------------------------------------------------------

El patrón de diseño Interpreter, se usa para definir un lenguaje para representar expresiones regulares que representen cadenas a buscar dentro de otras cadenas. Además, en general, para definir un lenguaje que permita representar las distintas instancias de una familia de problemas.

----------------------------------------------------------------------------------------------------------------------------------


Ahora explicaré por qué consideré estos patrones:

Primero,

El patrón Iterator, debido a que los productos son guardados en listas, para poder imprimirlos hay que usar un iterador que recorra las listas buscando información alojada y si la encuentra, la imprime a la pantalla.

El patrón Interpreter, es debido a que tuve que crear objetos que me reconocieran los tipos de datos enteros y flotantes y poder generar las listas de productos, y así pueda guardar e imprimir cadenas de datos.

Cualquier comentario o corrección es bien recibida, honestamente no le entendí muy bien a este tema.

Saludos

jueves, 24 de marzo de 2011

Avance Parcial de mi Proyecto

Buenos Días, aquí les adjunto el código y algunas capturas de pantalla del avance que llevo en mi proyecto.
Por el momento cuento con un menú con 3 opciones Agregar Productos, Mostrar Listado, Salir.

La Clase Principal es Grocery, aquí aparece el menú principal de acceso a las opciones del Sistema.

package avance;
import java.util.Scanner;

public class Grocery{
 
 public static void main(String[]args)   //funcion main
      {
     Scanner lectura = new Scanner(System.in);  //declaracion del scanner para poder leer los datos ingresados por el teclado
     
   Product Nombre = new Product();  //creamos un objeto para enlazar la clase Grocery con Product
   Inventory imprimir = new Inventory(); //creamos un objeto para enlazar la clase Grocery con Inventory
         
         int op=0;  //esta variable controla la opcion del programa a la que queremos acceder
         
         System.out.println ("Almacen Cuellar");
         System.out.println ("=================================");
         do
           {
              System.out.println ("Elije una Opcion:...");
               System.out.println ("[1]Para Ingresar Productos->  ");     //menu de opciones
              System.out.println ("[2]Para Mostrar Inventario -> ");
              System.out.println ("[3]Para Finalizar");
              
              do
                {
                 op = lectura.nextInt();
                 
                } 
              while(op!=1&&op!=2&&op!=3);  
              switch(op)
                {
                 case 1: Nombre.ingproducto();
                         break;
                 case 2: imprimir.printlist(Nombre);
                         break;         
                 case 3: System.out.println ("Fin Del Programa");
                         break;                        
                }
           }
         while(op!=3);  
      }
 }
 

Después está la Clase Product que es la encargada de recibir los datos para la generación del inventario de productos que se venden en el negocio.

package avance;

import java.util.Scanner;
import java.util.*;
import java.lang.*;

public class Product{
 
 
 
 public String Nombre;
 private int ID,Cantidad;                   //nombramos los atributos para agregar los productos
 private float Precio;
 
 
    List list = new ArrayList();             //generamos listas de los datos que queremos almacenar
   List listid = new ArrayList();         //en el inventario
   List listcant = new ArrayList();
   List listprice = new ArrayList();
    
 
     protected void ingproducto()    //metodo donde accedemos para ingresar productos
      {
     Integer ID = new Integer(0);       //creamos un objeto para guardar los datos de tipo entero
     Float Precio = new Float(0);       //creamos un objeto para guardar los datos de tipo flotante
     
     Scanner lectura = new Scanner(System.in);
     
         System.out.println ("Ingreso De Datos Del Producto");
         System.out.println ("=============================");         //menu de opciones para dar de alta un producto
         System.out.println ("Ingrese el Nombre del Producto-> ");
         Nombre = lectura.nextLine();  //guardar el nombre
         list.add(Nombre);     //agregarlo a la lista
         System.out.println ("Ingrese el ID del Producto-> ");
         ID = lectura.nextInt();   //guardar el ID
         listid.add(ID);       //agregarlo a la lista
         System.out.println ("Ingrese la Cantidad de Productos Disponibles-> ");
         Cantidad = lectura.nextInt();   //guardar la cantidad
         listcant.add(Cantidad);    //agregarlo a la lista
         System.out.println ("Ingrese el Precio Producto-> ");
         Precio = lectura.nextFloat();     //guardar el precio
         listprice.add(Precio);          //agregarlo a la lista
         
      }  
      
  }


Y por último está la clase Inventory, encargada de generar y guardar las listas de productos agregados desde la opción agregar y tiene un acceso desde el menú principal para acceder al inventario que se ha generado hasta el momento.

package avance;
import java.util.*;

public class Inventory{
 
 
  
 static void printlist(Product imprimir){    //metodo estatico para obtener los valores ingresados en producto
                                             //e imprimirlos, tambien es el metodo para acceder al listado del inventario generado
  
  System.out.println("Lista de Inventario\n"); 
  Iterator iter = imprimir.list.iterator();                //recorrer la lista de nombres de productos guardados e imprimirlos
   while (iter.hasNext())
    System.out.println("Nombre: "+iter.next());
    
  Iterator itera = imprimir.listid.iterator();
   while (itera.hasNext())        //recorrer la lista de ID's guardados e imprimirlos
    System.out.println("ID: "+itera.next());
    
  Iterator iterac = imprimir.listcant.iterator();
   while (iterac.hasNext())       //recorrer la lista de cantidades de productos guardados e imprimirlos
    System.out.println("Cantidad Disponible: "+iterac.next());
    
  Iterator iteraci = imprimir.listprice.iterator();  //recorrer la lista de precios de productos guardados e imprimirlos
   while (iteraci.hasNext())       
    System.out.println("Precio Unitario: "+iteraci.next());
 }
 
} 

Finalmente aquí adjunto unas capturas de pantalla con la compilación y ejecución del programa.

miércoles, 23 de marzo de 2011

Video Presentación de Diágramas de Proyecto

Que tal, aquí está el link de youtube con el video explicativo de los diágramas UML de mi proyecto.

Saludos

http://www.youtube.com/watch?v=p-ce8ljcu_8

miércoles, 16 de marzo de 2011

Diagramas de Clase y Secuencia de UML (TALLER)

El Software que utilice para generar el codigo a partir del diagrama de clases fue el Umbrello.

Aqui una captura del diagrama de clases en Umbrello:

Ahora generamos el código a partir de dicho diagrama:
Primero que nada hay que crear un directorio en el cual Umbrello pueda guardar el codigo generado, recomendaría hacerlo en el Desktop, para acceder a el más fácil.

Una vez creado el directorio regresamos a Umbrello, nos vamos a ir a la barra de herramientas superior clic en Settings, nos vamos a Configure Umbrello UML Modeller... y damos clic a la pestaña Code Generation, se desplegara esto:

Ahi seleccionamos lenguaje Java o el que esten utilizando, ahora en el apartado Folders en la opción "Write all generated files to folder" ahí pondrán la dirección en la que esta alojado el directorio que crearon anteriormente, lo demás lo dejan igual y por último dan clic en Ok.

Se van al Desktop o a la dirección en la que guardaron inicialmente el Folder y deberan aparecerles las clases que generaron en su diagrama:

 Y este es el código que me generó Umbrello para cada una de las clases:


Clase Grocery:


/**

import java.util.*;


/**
 * Class Grocery
 */
public class Grocery {

  //
  // Fields
  //

  
  //
  // Constructors
  //
  public Grocery () { };
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  //
  // Other methods
  //

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


}

Para Product:


/**

import java.util.*;


/**
 * Class Product
 */
public class Product {

  //
  // Fields
  //

  public int ID;
  public float price;
  public int quantity;
  public String description;
  
  //
  // Constructors
  //
  public Product () { };
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  /**
   * Set the value of ID
   * @param newVar the new value of ID
   */
  public void setID ( int newVar ) {
    ID = newVar;
  }

  /**
   * Get the value of ID
   * @return the value of ID
   */
  public int getID ( ) {
    return ID;
  }

  /**
   * Set the value of price
   * @param newVar the new value of price
   */
  public void setPrice ( float newVar ) {
    price = newVar;
  }

  /**
   * Get the value of price
   * @return the value of price
   */
  public float getPrice ( ) {
    return price;
  }

  /**
   * Set the value of quantity
   * @param newVar the new value of quantity
   */
  public void setQuantity ( int newVar ) {
    quantity = newVar;
  }

  /**
   * Get the value of quantity
   * @return the value of quantity
   */
  public int getQuantity ( ) {
    return quantity;
  }

  /**
   * Set the value of description
   * @param newVar the new value of description
   */
  public void setDescription ( String newVar ) {
    description = newVar;
  }

  /**
   * Get the value of description
   * @return the value of description
   */
  public String getDescription ( ) {
    return description;
  }

  //
  // Other methods
  //

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


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


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


}

Para Inventory:

/**
import java.util.*;


/**
 * Class Inventory
 */
public class Inventory {

  //
  // Fields
  //

  
  //
  // Constructors
  //
  public Inventory () { };
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  //
  // Other methods
  //

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


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


}

Para Purchase:

/**
import java.util.*;


/**
 * Class Purchase
 */
public class Purchase extends Inventory {

  //
  // Fields
  //

  
  //
  // Constructors
  //
  public Purchase () { };
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  //
  // Other methods
  //

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


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


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


}

Codigo que ire analizando y programando para el desarrollo de mi proyecto.

Diagramas de Clase y Secuencia de UML (CLASE)

Diagrama de Clase Correspondiente a mi Proyecto:

Explicación: Mi clase principal es Grocery, en ella se va a encontrar la interfaz o menú principal en el que el administrador va a acceder a las diferentes opciones de administración y control de productos e inventarios del negocio. 
Después esta la clase Product donde se agregan, modifican y eliminan productos, esta va ligada con la clase Inventario debido a que cada producto que se agrega se guarda en la clase Inventario.
La clase Inventario, es dónde se alojan los productos agregados y hereda la clase Purchase, clase en la que el administrador genera pedidos de los clientes y tal clase ademas de ser hija de inventario tiene una relación con ella al momento de hacer búsquedas de productos y así poder dar un presupuesto y/o mensaje de si procede o no el pedido.

Diagrama de Secuencia Correspondiente a mi Proyecto.
Explicación: El programa inicia en la clase Grocery, después pasa a la etapa de agregar un producto, al agregarlo se enlaza y guarda al inventario y regresa al Menu, al terminar de agregar los productos se accede a la opción Purchase, para realizar un pedido, este lee los datos y busca si se cuenta con lo necesitado para concretar la venta y nos regresa la respuesta.

Por el momento esas son los métodos que considero más fundamentales para lograr el objetivo de mi proyecto.

lunes, 14 de marzo de 2011

Diagramas de Clase y Secuencia de UML (CLASE) (ENTRADA 1/2)

Diagrama de Clases

Un diagrama de clases es un tipo de diagrama estático que describe la estructura de un sistema mostrando sus clases, atributos y las relaciones entre ellos. Los diagramas de clases son utilizados durante el proceso de análisis y diseño de los sistemas, donde se crea el diseño conceptual de la información que se manejará en el sistema, y los componentes que se encargaran del funcionamiento y la relación entre uno y otro.

Ejemplo de Diagrama de Clases:


Explicación:

Este diagrama corresponde a un juego, por lo que veo un juego de vaqueros no sé que opinen ustedes jeje.

Como pueden observar, el juego consta de 5 Clases,  Personaje, Vaquero, Vaca, Cerca, Juego.

La clase Personaje cuenta con 4 atributos o variables de Instancia  -bmps que supongo es algo de los graficos o imágenes que representaran a tales personajes.
- posicion actual: tupla; lo de tupla es porque el programa puede que utilize algun grafo que  tendra que ir reconociendo que lugares ha pizado el personaje para poder definir que lugar sigue por pizar.
- velocidad que es un flotante supongo que esto va a controlar los cuadros/segundo en que se movera el personaje
-estado es un entero  el estado puede controlar o identificar cuando el personaje está moviendose o cuando el personaje está en reposo.

Los métodos con los que cuenta esta clase son todos públicos: mover el personaje, dibujar el personaje, cambiar estado, detectar colision.

Las Clases Vaquero y Vaca tienen una relación de herencia con la clase Personaje; los atributos que comparten son: las posiciones (que son atributos privados) en las que se encuentran estos tanto iniciales como finales.

La Clase Vaquero tiene un atributo que se llama dirección que creo se encarga de las posibles rutas o destinos que puede seguir este para moverse, mientras que la clase Vaca maneja como una posición inicial y de destino donde las vacas estaran posecionadas en un solo lugar y se moveran siempre igual, además la clase Vaca cuenta con dos atributos públicos hermanas que es una instancia para generar más vacas y el cercado  que es una instancia para generar una cerca que rodeara a estas o servira como algun obstaculo.

La Clase Cerca cuenta con 2 atributos que también son tuplas, posicion inicial y posicion final y un metodo que consiste en crear una posicion default para las cercas.

Y por último la Clase Juego, clase que deriva a todas las demás, los rombos de relación sin relleno lo que significa que es un tipo de agregación por referencia (el tiempo de vida del objeto incluido es independiente del que lo incluye). Pero en forma general, la clase Juego es muy importante en la implementación de este juego ya que sin un nivel de dificultad, el programa arrojaría siempre el mismo nivel y no que con este atributo pueden desarrollarse más ampliamente las características e implementaciones de las demás clases.

Referencias:
http://bittacorp.wordpress.com/2008/11/26/diagrama-de-clases/
http://es.wikipedia.org/wiki/Tupla
http://es.wikipedia.org/wiki/Diagrama_de_clases

Un muy buen tutorial sobre diagramas de clases:
http://www.dcc.uchile.cl/~psalinas/uml/modelo.html