Interfaces Gráficas

Programación Orientada a Objetos - Semana 13 - Reporte 12

Interfaces Gráficas en JAVA

Las GUI (Graphic User Interface) o Interfaz Gráfica de Usuario es una forma de hacer los dispositivos más accesibles a los usuarios en general.

Las interfaces gráficas son en realidad un componente o programa que corre en segundo plano en el sistema donde se ha implementado, su función es transformar cada una de las instrucciones, métodos, acciones o comandos en componentes visuales (haciendo uso de imagenes, pequeños iconos, efectos y demás).

Todo esto convierte un entorno de línea de comandos en un entorno visual más atractivo e intuitivo al usuario lo que es una invitación a utilizar nuestro sistema o aplicación

La necesidad de las interfaces gráficas surge como una consecuencia de la falta de conocimientos por parte de los usuarios sobre el manejo y uso de las CLI (Interfaces de Línea de Comandos) había la necesidad de masificar los sistemas, pero aprender cientos de instrucciones, sintaxis, parámetros y demás no era una buena solución.

Las Interfaces gráficas automatizan gran parte de este trabajo, ya que no es necesario aprender toda una instrucción textual, solo es necesario aprender la funcionalidad de un botón para lograr los resultados deseados.

Los sistemas operativos implementan diferentes gestores GUI o entornos de escritorio, solo por mencionar algunos:

• Windows XP: LUNA
• Windows Vista/Seven: AERO
• MAC OS: AQUA
• Linux: GNOME, UNITY, KCD

Java ofrece una serie de librerias que facilitan en gran medida la implementación interfaces gráficas.

java.awt(Abstract Windowing Toolkit)

Es el paquete original de herramientas GUI de Java. Las principales ventajas AWT son que viene incluída en todos los paquetes de tecnología Java, incluyendo implementaciones de Java en navegadores de Internet y es muy estable.

AWT es un conjunto de herramientas muy simples con pocos componentes GUI, administradores de diseño, y eventos.

Esto se debe a Sun Microsystems decidió utilizar un mínimo común denominador (LCD) para el enfoque de AWT.

Como resultado de ello, y por desgracia, algunos de los componentes de uso común, tales como tablas, árboles, barras de progreso, y otros, no son compatibles. Para las aplicaciones que necesitan más tipos de componentes, es necesario crearlas desde cero. Esta es una gran carga.

AWT ofrece tres tipos de componentes principales:

a) Básicos: Componentes básicos en cualquier GUI.

• Button
• CheckBox
• Container
• Panel
• Window
• Frame
• Label
• List
• TextComponent
• MenuComponent

b) Layouts: Sirven para acomodar los componentes de la GUI.

• FlowLayout
• GridLayout
• BorderLayout
• CardLayout
• GridBagLayout

c) Eventos: Otorgan funcionalidades a cada uno de los componentes de la GUI.

• KeyEvent
• ActionEvent
• MouseEvent
• TextEvent

javax.swing

El paquete Swing es parte de la JFC (Java Foundation Classes) en la plataforma Java. La JFC provee facilidades para ayudar a la gente a construir GUIs.

Las componentes Swing se identifican porque pertenecen al paquete javax.swing.

Swing existe desde la JDK 1.1 (como un agregado). Antes de la existencia de Swing, las interfaces gráficas con el usuario se realizaban a través de AWT (Abstract Window Toolkit), de quien Swing hereda todo el manejo de eventos. Usualmente, para toda componente AWT existe una componente Swing que la reemplaza, por ejemplo, la clase Button de AWT es reemplazada por la clase JButton de Swing (el nombre de todas las componentes Swing comienza con "J").

Las componentes de Swing utilizan la infraestructura de AWT, incluyendo el modelo de eventos AWT, el cual rige cómo una componente reacciona a eventos tales como, eventos de teclado, mouse, etc... Es por esto, que la mayoría de los programas Swing necesitan importar dos paquetes AWT: java.awt.* y java.awt.event.*.

Ojo: Como regla, los programas no deben usar componenetes pesados de AWT junto a componentes Swing, ya que los componentes de AWT son siempre pintados sobre los de Swing. (Por componentes pesadas de AWT se entiende Menu, ScrollPane y todas las componentes que heredan de las clases Canvas y Panel de AWT)

Swing abarca componentes como botones, tablas, marcos, paneles, ventanas, etc...

APLICACIÓN AL PROYECTO

Es clave en mi proyecto desarrollar una interfaz gráfica amigable para el usuario. Mi intención es desarrollar algo parecido a la factura en físico, con un orden parecido.

En general, la ventana siempre estará compuesta por 2 paneles. El panel de barra de menú y el panel del área de trabajo

El panel de menú tendrá diferentes opciones las cuales se activaran dependiendo del área de trabajo. Para ello implementaré un JMenuBar. Si alguien por ahí sabe como implementarlo pues no dude en comentar.

El área de trabajo sera dinámica, ya que es la que cambiará con cada opción que se elija. Para ello se deberán utilizar de manera creativa los Layouts disponibles en java.awt.
Algunos paneles que me serán útiles son GridLayout, BorderLayout, FlowLayout y el dios GridBagLayout :).
Otros componentes necesarios para mi proyecto serán los básicos: JLabel, JButton, JTextField, JTextArea; asi como implementar de forma correcta el JTable

SALUDOS!! :)

REFERENCIAS

• http://www.roseindia.net/java/example/java/awt/
• http://www.dcc.uchile.cl/~lmateu/CC60H/Trabajos/edavis/swing.html
• http://www.ibm.com/developerworks/grid/library/os-swingswt/
• http://en.wikipedia.org/wiki/Swing_(Java)
• http://en.wikipedia.org/wiki/Abstract_Window_Toolkit

Presentacion Final

Programación Orientada a Objetos - Semana 14 - Reporte 13

Presentación Final



SALUDOS :)

Sistemas Distribuídos

Programación Orientada a Objetos - Semana 12 - Reporte 11

SISTEMAS DISTRIBUIDOS

Un sistema distribuido se define como: una colección de computadoras separadas físicamente y conectadas entre sí por una red de comunicaciones distribuida; cada máquina posee sus componentes de hardware y software que el usuario percibe como un solo sistema (no necesita saber qué cosas están en qué máquinas).

El usuario accede a los recursos remotos (RPC) de la misma manera en que accede a recursos locales, o un grupo de computadores que usan un software para conseguir un objetivo en común.

Los sistemas distribuidos deben ser muy confiables, ya que si un componente del sistema se descompone otro componente debe de ser capaz de reemplazarlo, esto se denomina Tolerancia a Fallos.

El tamaño de un sistema distribuido puede ser muy variado, ya sean decenas de hosts (red de área local), centenas de hosts (red de área metropolitana), y miles o millones de hosts (Internet); esto se denomina escalabilidad.

En Java se puede utilizar la Invocación Remota de Métodos o RMI para establecer un sistema distribuido.

El sistema de Invocación Remota de Métodos (RMI [Remote Method Invocation] ) de Java permite a un objeto que se está ejecutando en una Máquina Virtual Java (VM) llamar a métodos de otro objeto que está en otra VM diferente compartiendo así recursos y carga de procesamiento a través de varios sistemas.

Existen tres procesos que participan en una aplicación RMI:

1. Cliente (Client): Es el proceso que invoca los métodos de los objetos remotos.
2. Servidor (Server): Es el proceso que crea los objetos, hace referencia a los mismos y espera a que sean invocados por el cliente.
3. Registro de Objetos (Object Registry): Crea las referencias a los objetos en el servidor. Los objetos son registrados con éste proceso y una vez que son registrados se puede obtener acceso al mismo con tan solo su nombre.

Las aplicaciones distribuidas deben cumplir 3 tareas específicas para funcionar:

1. Localizar objetos remotos. Las aplicaciones pueden utilizar diversos mecanismos para obtener referencias a objetos remotos. Por ejemplo, una aplicación puede registrar sus objetos remotos con el registro RMI. Por otra parte, una aplicación puede pasar y devolver referencias de objetos remotos como parte de otras invocaciones remotas.
2. Comunicarse con objetos remotos. Los detalles de la comunicación entre objetos remotos son manejados por el RMI. Para el programador, la comunicación a distancia es similar a regular llamadas a métodos Java.
3. Cargar las definiciones de clases para los objetos que se pasan a través de la aplicación. Debido a que RMI permite a los objetos pasar en dos direcciones (Ida y Vuelta), se proporciona mecanismos para cargar las definiciones de clase de un objeto, así como para la transmisión de datos de un objeto.

La siguiente ilustración muestra una aplicación RMI distribuida que utiliza el registroRMI para obtener una referencia a un objeto remoto. El servidor llama al registro paraasociar (o unen) un nombre con un objeto remoto. El cliente busca el objeto remotopor su nombre en el registro del servidor y luego invoca un método en él. La ilustración también muestra que el sistema RMI utiliza un servidor Web existentepara cargar las definiciones de clase, del servidor al cliente y del cliente al servidor,para los objetos cuando sea necesario.

Realizar un sistema distribuido con RMI es algo sencillo, se pueden seguir los siguientes pasos:

1. Crear un servidor RMI

• Definir un objeto remoto que va a ser utilizado por los clientes. Para crear un objeto remoto...
• Definir una interfaz, y el objeto remoto será una clase que implemente dicha interfaz.

2. Definir el interfaz remoto

• El interfaz debe ser público.
• Debe extender (heredar de) el interfaz java.rmi.Remote, para indicar que puede llamarse desde cualquier máquina virtual Java.
• Cada método remoto debe lanzar la excepción java.rmi.RemoteException en su claúsula throws, además de las excepciones que pueda manejar.

APLICACIÓN AL PROYECTO

En el caso de mi proyecto, mi idea es aplicar algo equivalente al servicio que ofrecen las tiendas de conveniencia en línea.

Seria un portal, ya sea en línea o por medio de una aplicación java móvil que permite descargar la factura en formato PDF a la computadora o dispositivo móvil.

Por ahora y por el poco tiempo restante, solo me encargaría de hacer el sistema en línea.

Como método de autentificación se pediría el RFC del cliente (esté a su vez se convertiría en un filtro para solo mostrar las facturas almacenadas en la base de datos que correspondan a ese cliente)

Después, si lo sabe el cliente, se pediría el folio de la factura a descargar. Si el cliente no sabe el folio de la factura se procede a imprimir una lista de las facturas correspondientes al cliente para que pueda verificar y descargar la que desee.

Una vez seleccionada la factura, el programa, en silencio, recupera la factura y arma un PDF que puede ser descargado.

REFERENCIAS

• http://www.programacion.com/articulo/invocacion_remota_de_metodos_rmi_107/
• http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=rmi
• http://www.eg.bucknell.edu/~cs379/DistributedSystems/rmi_tut.html
• http://yama-linux.cc.kagoshima-u.ac.jp/~yamanoue/researches/java/rmi-ex2/
• http://www.java2s.com/Code/Java/Network-Protocol/RMIDemo.htm
• http://es.wikipedia.org/wiki/Computaci%C3%B3n_distribuida

Identificación de Eventos, Excepciones y Errores propios

Programación Orientada a Objetos - Semana 10 - Reporte 9

Cuando diseñamos una aplicación todos estamos expuestos a los errores y las excepciones. De la misma forma, generamos eventos que nos sirven para realizar diversas acciones dentro de nuestro programa.

EVENTOS

Los eventos, como ya mencioné, son acciones que el usuario inicia y que el programa procesa regresando un resultado, lo que se conoce como respuesta (por lo general, aunque no siempre).

En java, la clase padre de todo tipo de eventos es la clase java.awt.Event

Algunos tipos de eventos son:

- KeyEvent: se produce cuando el usuario presiona alguna tecla.

- MouseEvent: cuando el usuario mueve el mouse o presiona alguno de los botones del mismo.

- WindowEvent: son eventos relacionados con las ventanas de la aplicación, ejemplos pueden ser abrir la ventana o cerrarla.

- ActionEvent: son eventos variados, acciones que se realizan sobre los componentes de la aplicación, por ejemplo el presionar un botón.

- TextEvent: relacionados al texto, se producen por ejemplo al cambiar el texto que ingresamos.

Java captura los eventos utilizando interfaces de escucha o Listeners. Para cada tipo de evento hay una interfaz de escucha:

- MouseEvent , MouseListener

- ActionEvent , ActionListener.

EXCEPCIONES

Las excepciones son situaciones eventuales que pueden presentarse dentro del tiempo de ejecución de nuestro programa, por lo general, una excepción la podemos identificar antes de tiempo y así programar la manera en la que nuestro programa deberá capturarla y gestionarla. Tras capturar la excepción, es posible, si así se desea, continuar desde el punto donde se produjo la excepción.

Las hay de dos tipos:

- RuntimeException: errores en el tiempo de ejecución. Son causadas por los programadores, por ejemplo, si se divide entre cero o se intenta acceder mas allá de la memoria reservada para un arreglo.

- IOException: errores de entrada y salida. Por ejemplo, intentar accesar o modificar archivos inexistentes, o sin el permiso requerido.

Cuando se produce un error, se genera un objeto Throwable. Los objetos Throwable contienen un mensaje (String) que almacena una descripción del error; la pila de memoria (stack) existente al momento de generar el objeto y la causa, tambien de tipo Throwable con la que podemos presentar el error en sí.

Las excepciones se capturan mediante los bloques try - catch. Cada sentencia try debe ir seguida de una sentencia catch, y cada método o clase puede indicar el tipo de objeto Throwable a lanzar. Por ejemplo:

public void function () throws IOException  {

...

// código libre de excepciones

...

try {

    ...

    // código que posiblemente lance una excepción

    ...

} catch (IOException error) {

    ...

    // qué hacer en caso de excepción

    ...

}

}

ERRORES

Los errores por lo general, van más allá de nuestro alcance. Son situaciones criticas que no podemos manejar de forma habitual, incluso, no deberíamos intentar capturarlas y gestionarlas. Indican otro tipo de fallos de los cuales no podemos recuperarnos y solo queda finalizar la ejecución del programa.

Los errores más tipicos hacen referencia a fallos del sistema:

- Memoria agotada.

- Accesar a espacios ya reservados, por otros programas, en la memoria.

- Sobrecarga del procesador.

- Perdida de la conexión a base de datos, internet.

- Problemas de hardware.

Por lo general este tipo de errores deben visualizarse antes que todo, es decir, verificar las capacidades del sistema al cual orientamos nuestro programa, evitar errores en la lógica de la aplicación que causen ciclos o procesos infinitos que sobrecarguen el sistema, etcétera.

Errores y excepciones detienen la ejecución normal de nuestro código, los errores son los únicos que pueden forzarnos a cerrar nuestra aplicación, en cambio, las excepciones, nos permiten continuar la ejecución normal de nuestro código sabiendo manejar dichas excepciones de forma correcta.

IDENTIFICACIÓN DE EVENTOS, ERRORES Y EXCEPCIONES EN MI PROYECTO.

Eventos propios.

La gran mayoría de mis eventos estarán enfocados a la interfaz gráfica, más que nada al tipo ActionEvent ya que colocare una gran cantidad de botones en algo que emulará una barra de herramientas.

Además incluiré varios eventos de tipo TextEvent, estos eventos notificarán a mi aplicación cuando los datos de una factura que vaya ingresando sean modificados.

Excepciones.

Muchas excepciones han sido previstas por mi código. Comenzando por las básicas que son las de entrada y salida.

Dentro de los menús principal y secundarios: ¿Estás eligiendo una opción válida?. De no ser así, se produce una excepción con un mensaje y se vuelve a dar la oportunidad de elegir la opción válida.

Dentro del módulo de facturación, lo primero que se hace es cargar los datos de la empresa (proveedor, supplier), guardados en un archivo: ¿Existe el archivo? ¿Es el correcto?. Si no es así, la excepción permite llenar un segundo archivo correcto y es el que se procede a cargar. El primer archivo, de estar ahí, se convierte en basura y el segundo se convierte en el archivo correcto.

En el módulo de facturación, al crear nueva factura hay que pedir los datos: ¿Es el tipo de dato correcto? Esto más que nada se produce al pedir cantidades numéricas, por ejemplo precios o cantidad de artículos. Te pido un Integer o Double, pero me das un carácter; la excepción muestra un mensaje y te permite dar otro valor.

En la base de datos. ¿Se pudo abrir la base de datos? ¿Se pudo guardar el dato? ¿Se pudo accesar a los datos?. La excepción mostrara un mensaje según corresponda.

Errores

Hasta ahora no tengo ningún error previsto, pero algunos de ellos pueden ser:

En la lista de artículos de la factura, la lista es tan grande que te haz quedado sin memoria.

La interfaz gráfica es muy pesada o elaborada, algunos sistemas no pueden cargarla ocasionando la finalización del programa.

El iterador, al leer los nodos de la lista siguió un ciclo infinito y sobrecarga el procesador.

Hemos usado comandos de sistema y el código no es portable, ocasionando errores de compatibilidad.

Librerías que no están presentes ocasionando errores de ejecución y el mal funcionamiento de ciertas partes del código.

Referencias

http://www.slideshare.net/sgvargas/manejo-de-eventos-en-java-presentation

http://www.slideshare.net/eccutpl/gestin-de-errores-en-java

http://elvex.ugr.es/decsai/java/pdf/B2-excepciones.pdf

Identificación de Patrones Diseño

Programación Orientada a Objetos - Semana 9 - Reporte 8

Un patrón es algún evento, suceso, objeto, en sí cualquier cosa que se repite en el tiempo.

Por ejemplo, en una fábrica se pueden producir diferentes tipos de artículos, por ejemplo, un jabón. El producto puede ir desde un jabón neutro, hasta uno aromatizado. Para todos se sigue un patrón el cual varía solamente al final, cuando se generan productos concretos desde un producto base. Entonces, se puede decir que el patrón es toda la línea de producción, ya que es un proceso recurrente que tiene como resultado uno o varios productos.

El mundo del software no es la excepción, existen problemas recurrentes a los cuales puede aplicarse un patrón, dichos patrones reciben el nombre de Patrón de Diseño.

"Los patrones de diseño son el esqueleto de las soluciones a problemas comunes en el desarrollo de software. Son una descripción de clases y objetos comunicándose entre sí adaptada para resolver un problema de diseño general en un contexto particular."

Los patrones nos brindan soluciones (probadas) a problemas en el desarrollo de software los cuales están sujetos a contextos similares. Por ejemplo, un software de llenado se formas, recibos, facturas, cheques, etcétera, todos pueden tener una finalidad diferente, pero todos tienen un patrón parecido para el llenado de información por lo que su codificación puede ser parecida o la misma; a todos los anteriores se les puede aplicar un patrón de diseño igual.

Existen tres clases de patrones de diseño:

De creación: conciernen al proceso de creación de objetos.

De estructura: tratan la composición de clases y/o objetos.

De comportamiento: caracterizan las formas en las que interactúan y reparten responsabilidades las distintas clases u objetos.

Algunas de las ventajas de usar patrones de diseño son:

Indican cómo resolver un problema particular utilizando un pequeño número de clases relacionadas de forma determinada, pero no indican cómo diseñar un sistema completo, sino sólo aspectos puntuales del mismo.

Facilitan la re utilización de las clases y del propio diseño.

La propia estructura del patrón es reutilizada cada vez que se aplica.

A pesar de ser muy útiles, rara vez se nota su efecto sobre el código y es casi imposible saber que patrón fue utilizado en su desarrollo. También suele ser necesario programas más clases que las necesarias y se produce una sobrecarga en el código

IDENTIFICACIÓN EN EL PROYECTO

Encontré dos patrones que pueden aplicarse al proyecto:

BUILDER PATTERN (Constructor - Tipo Creacional)

Es un patrón de diseño creacional. Separa la construcción de un objeto complejo y a partir de ese proceso se pueden generar distintas representaciones de dicho objeto.

Para aplicar éste patrón se necesita:

- Constructor: especifica una interfaz abstracta para crear un objeto complejo Producto.

- Constructor Concreto: construye y ensambla las partes del Producto implementando la interfaz de Constructor.

- Director: obtiene las partes que forman el Producto y lo construye usando la interfaz de Constructor.

- Parte: representa las partes que se usan para construir el Producto.

- Producto: representa el objeto complejo en construcción.

Yo lo puedo utilizar al generar una factura ya que la generación de una factura necesita un proceso de llenado de formas, esta es la base o patrón.

Además necesito primero generar las partes que componen una factura:

1. Crear el proveedor del servicio.

2. Crear el origen de la carga.

3. Crear el destino de la carga.

4. Crear el pedido (que contiene la carga)

5. Realizar los cálculos (totales, descuentos, impuestos)

6. Armar la factura.

7. Exportar a PDF ó Generar factura electrónica ó Generar una factura impresa.

Como se puede observar, primero se sigue un mismo patrón, dividiendo un objeto complejo en pequeñas partes para posteriormente juntarlas y obtener un producto.

Después con el mismo patrón puedo obtener diferentes presentaciones del mismo producto

COMPOSITE PATTERN (Compuesto - Tipo Estructural)

El Patrón compuesto realiza una jerarquización en forma de "árbol" entre los objetos y así mostrar una relación parte-todo. Incluso se pueden tomar las variables de un objeto como nodos hoja las cuales siguen formando parte de un todo.

Este patrón se usa cuando los objetos tienen cierta jerarquía en el código y cuando ciertas operaciones se realizan en uno o varios objetos.

Una de las formas en que yo puedo utilizar este patrón es al momento de tomar los datos del cliente:

Como pueden ver en la imagen de ejemplo, cada campo de una forma es una hoja, una parte individual de un todo, 2 o más de dichos campos generan un objeto compuesto y así sucesivamente hasta llegar al producto final, es éste caso, una forma.

En mi caso la secuencia sería la siguiente:

1. Los campos para los datos del Origen.

2. Los campos para los datos del Destino.

3. Los campos para tomar la Orden.

En éste caso, los campos son las hojas de los objetos compuestos (Origen, Destino, Orden)

4. Los objetos que forman una Factura.

Origen, Destino y Orden son "hojas" de un objeto compuesto, la factura.

5. Las facturas que forman al objeto compuesto, base de datos.

Todas las facturas son hojas de una base de datos.

El Patrón Compuesto es bueno usarlo cuando necesitamos implementar un código que necesite agregar, remover, borrar, modificar, guardar, etcétera; algún dato u objeto, es decir, cuando se implementa algo parecido a una base de datos o un registro.

ITERATOR (Iterador - De comportamiento)

Posiblemente lo usemos y no nos demos cuenta, es un buen patrón de diseño cuando necesitamos acceder a información de manera secuencial.

- Cuando se quiere acceder al contenido de un objeto agregado sin revelar su representación interna.-

- Cuando se quiere permitir múltiples tipos de recorridos sobre objetos agregados.

- Cuando se quiere proporcionar una interfaz uniforme para recorrer diferentes estructuras de agregación.

Éste patrón lo utilizo en cierto momento de mi código, cuando necesito accesar a los datos que almacene en la Orden, mi objeto Orden es una lista de Conceptos a facturar, entonces yo necesito accesar a dicha lista por medio de un iterador para observar las características de cada uno.

También necesito accesar a la información de la base de datos una vez que la almaceno temporalmente en el programa.

Cuando implemente la búsqueda de Clientes o Facturas, necesitaré almacenar todas las coincidencias en una lista temporal, y posteriormente accesar a ella mediante un Iterador para observar el objeto buscado.

Bueno amigos, estos son los Patrones de Diseño que relaciono con mi proyecto, además, espero que les sea útil la información y para posteriores referencias les dejo las páginas que visité para saber más sobre patrones de diseño.

Patrones de Diseño - PDF - Vía FTP

Patrones de Diseño - Presentación

Y un libro que se llama PRO JavaScript Design Patterns (Ya no tengo el link pero es un libro que obtuve en PDF)

SALUDOS

Presentación de Diagramas UML y de Secuencia

Programación Orientada a Objetos - Semana 8 - Reporte 7

Hola a todos!!

Estas son las diapositivas que corresponden a la presentación de mis diagramas, referentes a mi proyecto.

Este es el diagrama UML correspondiente a mi diseño actual. Cabe mencionar que con este diseño he logrado implementar algo de código que funciona correctamente.

A grandes rasgos, en primer lugar podemos ver que todas mis clases están encapsuladas dentro del paquete toBill.

(De izquierda a derecha) Posteriormente tenemos la clase Billing que por ahora funciona como la clase principal de mi programa, esta clase incluye otra llamada Proxy cuyo funcionamiento es crear un puente que comunique a la aplicación con la base de datos. Billing tiene como atributo una factura Bill.

Bill tiene como atributos un cliente, un proveedor y una orden (Client, Supplier, Order). Los métodos implementados dentro de la clase factura incluyen la capacidad de imprimirse a si misma, exportarse a otros formatos y realizar los cálculos necesarios.

La clase Person es la siguiente, de ella se dividen 2: Client y Supplier que son las 2 partes involucradas en el proceso de facturación. En esta clase se implementa un poco de herencia.

La clase siguiente es Order, la cual es una lista de Items o articulos a facturar. Order puede añadir artículos a la lista, removerlos e imprimir su contenido.

Por último tenemos a la clase Item que son cada uno de los conceptos o artículos a facturar. Se trata de nodos los cuales se van encadenando para formar una lista.

Aqui se visualiza el proceso actual que se sigue para armar una factura.

Todo comienza cuando el usuario inicia la aplicación lo cual genera un nuevo módulo de facturación Billing. Con ello se activan los métodos para continuar con el proceso.

Posteriormente se llama al método getData() el cual está dentro de Billing. getData() tomara uno a uno los datos del cliente y los irá almacenando en variables temporales; una vez terminado se generá un nuevo objeto Client y los valores de las variables temporales se envían a los atributos al constructor de Client, con lo que finaliza la primera parte que es generar el cliente.

Después, getData() comienza abriendo un ciclo con el cual se pretende pedir los artículos a facturar, el ciclo. Se genera la Order y un Item, se van pidiendo los datos del Item los cuales se almacenan en sus respectivas variables y una vez terminado, el Item se añade a la lista principal, es decir, Order.

Una vez generados estos dos objetos, se envían al constructor de Bill para generar la factura, la cual posteriormente se puede imprimir, exportar a otros formatos o guardar.

Espero le entiendan a mi presentación.

Dudas o sugerencias no duden en comentar

SALUDOS

Diagramas UML y Diagramas de Secuencia

Programación Orientada a Objetos - Semana 7 - Reporte 6

Usar diagramas UML resulta bastante útil cuando deseamos programar una aplicación bajo el paradígma orientado a objetos. Dichos diagramas nos ayudan a planear, visualizar y entender la estructura de nuestra aplicación en terminos de clases y jerarquías.

Para realizar los diagramas UML utilice la aplicación UMBRELLO, esta aplicación es capaz de generar código fuente a partir de nuestro diagrama, y viceversa.

DIAGRAMA UML

Aqui les muestro el diseño actual de mi aplicación. Todo está probado, es decir, compila y se ejecuta correctamente.

En él pueden observar la estructura principal del código que estoy implementando. Hasta arriba pueden ver que todas mis clases pertenecen al paquete toBill (facturar).

Después, en el siguiente nivel pueden ver las clases que necesito para hacer funcionar mi código, tengo primeramente la clase Billing que es el módulo principal de facturación, es decir, la clase que generará la interfaz gráfica. En esta clase se implementa otra subclase llamada Proxy que es la encargada de comunicar el módulo de facturación con la base de datos.

También necesito la factura en si, que esta representada por la clase Bill, tenemos como atributos un cliente, un proveedor y una orden (Client, Supplier, Order). Y la factura hasta ahora puede calcular sus totales y descuentos, exportarse a si misma a otros formatos e imprimirse. A partir de Bill se implementas 2 subclases más, Paper (factura en papel) y Electronic (factura digital).

También se especifica a las personas involucradas en la clase Person, la cual tiene como atributos todos los datos personales del cliente y del proveedor. Como se puede ver, apartir de esta clase se implementan dos subclases más: Supplier (o proveedor) y Client (o cliente).

Siguiendo en el segundo nivel, podemos observar la clase Order la cual tiene como atributos un Item (artículo) y numItems (número de artículos). Los métodos de la clase Order permiten: agregar artículos (add()), quitar artículos de la lista (remove()) e imprimir la lista de artículos (toPrintItems()).

Por último, la clase Items es una clase nueva, que implemente al diseñar mejor mi orden como una lista, entonces esto convierte a mis artículos en nodos de una lista. Mi orden es la lista y mis artículos los nodos. Esto me facilito mucho el diseño de la factura.

Como atributos se tiene un root que es el puntero a los nodos, el código del artículo, la descripción, la cantidad y el precio.

DIAGRAMA DE SECUENCIA

Aqui les muestro el diagrama de secuencia en el cual se detalla el proceso actual que se sigue para generar una factura. De igual forma, dicho proceso esta probado y se crean objetos completamente funcionales.

Primeramente, el Usuario va a inicializar el módulo de facturación generando un nuevo objeto Billing, como aún no tengo un menú implementado, el módulo de facturación pasa directamente a la función getData() en donde se pedirán los datos del cliente uno a uno. Después se crea el objeto Client y mediante el constructor se colocan las variables en su lugar.

Despues se va pidiendo la orden, artículo por artículo. Se crea la lista Order y se pide la información de cada Item despues de generán los Items para almacenar la información pedida y a la vez ligarlos a la lista. Mediante un loop while se van pidiendo más y más artículos hasta terminar, también podemos eliminarlos.
Por último se crea una nueva factura Bill y se le envían a su constructor la orden que acabamos de crear y el nuevo cliente. Esto da forma a la factura la cual posteriormente podemos Eliminar, guardar, imprimir o exportar

Espero les haya gustado mi explicación, y le hayan entendido. A mis colegas que estamos compartiendo la misma idea del proyecto, espero que les sirva.

SALUDOS :)

PROYECTO: Presentación de Temas

Programación Orientada a Objetos - Semana 5 - Reporte 5

Les subo las diapositivas de mi clase, están muy claras y creo no necesitan explicación alguna :)

PROYECTO: Documentación y Herramientas de desarrollo

Programación Orientada a Objetos – Semana 4 – Reporte 4

La documentación en cualquier producto es importante, nos dan las instrucciones a seguir en caso de que se genere alguna duda o problema, mucha gente no le da crédito a la documentación de un artículo y por lo general al abrir algo nuevo comenzamos por tirar los instructivos y hasta las pólizas de seguro sin ni siquiera darles un vistazo.

Nosotros como desarrolladores tenemos la obligación de proporcionar a nuestros clientes un documento claro y conciso donde explicamos al funcionamiento de nuestro software; esta será una futura referencia para todos aquellos que quieran ayudarnos a mejorar nuestro software y para guiarlos y que entiendan la visión que tuvimos al momento de construirlo; incluso será una referencia para nosotros mismos ya que en códigos extensos es imposible recordar para que funcionaba y que acción realizaba un segmento de nuestro código.

Por lo general, en los lenguajes de programación que así lo permiten, los comentarios son suficientes para colocar referencias en ciertas partes de nuestro código, sin embargo, existen ciertas herramientas que nos ayudan a generar documentos avanzados que permiten tener una perspectiva más amplia y detallada de las partes y funciones de nuestro software.

JAVADOC

El lenguaje de programación Java incluye una poderosa herramienta que nos permite generar la documentación de nuestro código de manera rápida y bastante profesional, su nombre es JAVADOC.

Javadoc es capaz de generar la documentación de nuestro código de manera instantánea y sin necesidad de abandonar la tradicional sintaxis de los comentarios dentro del código.

Metodología

La forma de generar la documentación por medio de Javadoc es simple, tan fácil como introducir comentarios dentro de nuestro código.

Simplemente tenemos que colocar la explicación ya sea de una clase, método o atributo dentro de un espacio parecido a este:

/**

*Aqui

*pon

*el 

*comentario

*

Como pueden ver, el inicio del comentario inicia con una diagonal y DOS asteriscos (los dos asteriscos son parte de la sintaxis de Javadoc, sirven como identificadores) y cada línea empieza con un asterisco y el comentario finaliza con un asterisco y una diagonal.

Si se quiere explicar el funcionamiento de una clase o función, el comentario de Javadoc se coloca justamente arriba de la misma, por ejemplo:

/**

* Clase de tipo Animal

* Genera un objeto animal

*/



public class Animal {

private String reino;

private String familia

}

En los métodos se puede colocar un identificador de parámetros que indica, valga la redundancia, los parámetros que dicho método recibe como atributos, para ello de escribe @param, y posteriormente el nombre del parámetro y la explicación del mismo. Así mismo el identificador @return indica el tipo y nombre del valor regresado por el método. Por ejemplo:

/**

* Divide un número entre otro número

* @param x Dividendo

* @param y Divisor

* @return El cociente de la division.

*/



Double division (double x, double y) {

…

Return cociente;

}

Para terminar, se deberá generar la documentación del código escribiendo en la terminal la instruccion Javadoc, con una sintaxis mas o menos asi:

javadoc ubicación

donde "ubicación" deberá sustituirse por la ubicación de nuestro paquete de clases, es como si fueramos a compilar pero utilizando el comando javadoc

Javadoc genera varios archivitos HTML y páginas de estilo CSS que en conjunto formaran una documentación muy parecida a la que encontramos en la página oficial de la API de Java. De igual forma podremos navegar por nuestra página donde veremos el resultado final de todos los comentarios que colocamos dentro del código.
Para más referencias sobre el uso, identificadores, sintaxis o tips acerca de Javadoc se puede visitar la página oficial del proyecto siguiendo esta liga:

Cómo escribir comentarios DOC usando la herramienta JAVADOC (inglés, página oficial)

El link lo agregaré a la barra de Recursos, la cual pueden encontrar en el Sidebar de mi blog.

Saludos!!!

☺ ☻ ☺ ☻

PROYECTO: Herencia y Polimorfismo

Programación Orientada a Objetos - Semana 3 - Reporte 3

Hola a todos. Para este reporte veremos cómo implementar la herencia y polimorfismo en el código de nuestro proyecto.

Para empezar veamos algunas definiciones y ejemplos rápidos:

HERENCIA: Cuando una clase padre (o superclase) comparte atributos y métodos propios con las clases hijas (o subclases).

Para que se entienda mejor:
En el mundo hay animales (superclase), pero hay diferentes tipos de animales (mamíferos, reptiles, aves, peces [subclases]). La clase animales hereda a las demás subclases algunos de sus atributos, por ejemplo: número de patas, color, tamaño, etcétera. A su vez hereda algunos métodos, por ejemplo: ver, oler, oir.

Las subclases pueden a su vez implementar métodos propios, por ejemplo: las avez vuelan, característica dificílmente compartible con los demás. Es el mismo caso con los peces, los cuales nadan y los demás no.

Atributos serían las características de los animales (físico, aunque no necesariamente), y los métodos serían lo que los animales hacen con dichos atributos.





POLIMORFISMO: La superclase puede hacer referencia a cualquiera de sus subclases, y dependiendo de dicha referencia, serán los métodos a ejecutar y su resultado.

Por ejemplo:
Animal hace referencia a la subclase mamífero y se ejecuta el método Desplazamiento y se imprime la línea ("Los mamíferos van sobre sus patas peludas").
En cambio si animal hace referencia a la subclase pez y se ejecuta el método Desplazamiento se imprimira la línea ("Los peces nadan con sus delicadas aletas").
El resultado depende de la referencia hecha por la superclase.

Aplicando al código

Hice una reformulación masiva de mi código para poder lograr que éste tema encajará en mi proyecto.

La herencia la aplicaré en la clase que ahora llamo Persona. Esta clase tiene 2 subclases idénticas llamadas Cliente y Proveedor, ambos comparten los atributos de la clase madre:

- Un nombre
- Una dirección
- Un RFC (Importantísimo en las facturas)
- Una empresa
- Etcétera

Ambas subclases se construyen de acuerdo a los atributos de la clase madre.

Una factura comparte atributos de otras clases, ya que una factura se genera a partir de un Cliente, un Proveedor y un Pedido (2 personas y 1 pedido). Entonces, haciendo uso de algunos métodos, se necesitan saber los atributos de las personas y del pedido para poder llenar la factura. Por consiguiente debe existir cierta herencia por parte de las personas hacia las facturas.

Un comunicación entre mi aplicación y mi base de datos necesita saber más cosas que ningún otro, primeramente necesito saber si he de buscar una factura o un cliente; sabiendo eso yo necesito usar los atributos de alguna de estas 2 clases para generar una buena búsqueda, alta, baja o modificación.

Es una explicación general de mi código, espero generar mas ideas conforme realizo mi código asi que espero hacer más conexiones raras entre mis clases conforme pasé el tiempo (no mucho :) ).

Saludos

PROYECTO: Definición de Clases

Programacion Orientada a Objetos - Semana 2 - Reporte 2

Para esta entrada trataré de explicar para que servirán algunas de las clases de mi código, las que mostraré aqui son las mas evidentes y conforme el código vaya creciendo se iran agregando mas clases.

Teniendo como ejemplo nuevamente la imagen de mi entrada anterior enlistare las clases que son identificables:

Clase Facturación:

Esta clase yo la visualizo como la principal, uno de sus objetivos es dibujar la ventana en la cual se llevaran acabo todas las acciones del programa, por consiguiente algunos de sus atributos seran efectivamente el tamano de la ventana, su forma, etc. Otro de sus objetivos será redireccionar todas las acciones generales del programa mediante botones porque una de mis intenciones es colocar una barra de herramientas que permita llamar a diferentes comandos directamente tales como abrir la base de datos, imprimir o modificar una factura, buscar, etcétera.

Clase Factura

La misma factura sera una clase, ya que tendrá diferentes atributos como el número de serie, el sello digital, datos del cliente y del vendedor y los artículos o servicios que se estan facturando. Puede crear un cliente, un proveedor y un pedido. Algunos de sus métodos serán ir armando la factura con los datos que se vayan pidiendo, importar la misma a otros formatos como PDF o formato electrónico (XML), imprimir o simplemente mostrar en pantalla la factura.

Clase Cliente

Esta clase como su nombre lo dice tendrá como atributos todos los datos personales y fiscales del cliente: nombre, dirección, RFC, etcétera.
Sus funciones realmente no son muchas y su funcionalidad depende mucho de la clase comunicación ya que esta clase envía sus datos a la clase comunicación quien después los manipula de diferentes formas.

Clase Proveedor

Será parecida a la clase cliente ya que almacenara todos los datos personales y fiscales del proveedor: nombre, dirección, RFC, etcétera.

Clase Pedido

Como su nombre indica, esta clase contendrá los datos necesarios para generar un producto: artículos, cantidad, precio, número de producto, etcétera. Como en la clase cliente esta necesita estar conectada a la clase comunicación quien es la que manipula los datos de diferentes maneras.

Clase Comunicación

Es posiblemente otra de las más importantes, tiene como atributos algunas variables que guardarán los datos enviados por las otras clases. Su función será la de apertura y cierre de archivos; lectura, escritura, borrado o modificación de las bases de datos. Como ya se habrán dado cuenta su función es ser intermediario entre el proceso de entrada y salida pues las clases Pedido o Cliente piden y generan datos y después esta clase los guarda, o también,mediante una petición previa, extrae datos de la base y después los reedirige ya sea a la clase Cliente o la clase Pedido.

Espero y tengan una perspectiva más amplia de mi proyecto :)

Referencias:
http://elvex.ugr.es/decsai/java/pdf/3B-Clases.pdf

PROYECTO: Herramientas

Taller de Programación Orientada a Objetos - Semana 1 - Reporte 1

Hola a todos !!

En esta entrada vamos a repasar las herramientas que vimos en clase y que nos serán útiles para nuestros proyectos.

LENGUAJES

Python

Este es un poderoso lenguaje de programación, se trata de un lenguaje multiparadigma y de alto nivel. Es muy fácil de aprender ya que su sintaxis es muy sencilla y ligera lo cual le otorga muchos puntos a favor.
Otra de las características es que cuenta con un soporte bastante completo en la web y librerías que facilitan el desarrollo de aplicaciones.
Es muy utilizado en las interfaces CGI.

Cómo empezar

Realmente no hay que empezar, Python viene completamente cargado en Ubuntu, para verificar su existencia basta con entrar a la Terminal y teclear:

which python

Lo que resultara en una ventana como la siguiente:


Esa línea que se nos es mostrada (que por lo general es /usr/bin/python) es lo que se conoce como interprete, esa línea hay que incluirla en cada uno de los códigos que escribamos en este lenguaje, por ejemplo:

 #!/usr/bin/python
print "\t\tOBTENER EL PORCENTAJE DE UN TOTAL\n"
x = float(input("Dame el valor total ->  "))
y = float(input("Porcentaje  obtener ->  "))
porcentaje = x*y/100
print "El resultado es -> "
print porcentaje

El script es un ejemplo muy austero de cómo obtener un porcentaje.

ESTA ES UNA ENTRADA ANTERIOR DONDE EXPLICO MUY A FONDO LAS CARACTERÍSTICAS DE PYTHON: Click aqui

C++

Es una extensión del lenguaje C, a través de la cual se le proporciona de programación orientada a objetos. Para los que hemos programado en C nos será relativamente fácil entender este lenguaje ya que la sintaxis es la misma a excepción por supuesto de aquellas funciones de la POO.

Cómo empezar

Depende de la versión de Ubuntu, la versión 10.04 incluía el compilador g++, pero, la versión 10.10 ya no lo incluye.

Para verificar su existencia basta con entrar a la terminal y teclear:

g++

Se nos pueden presentar 2 situaciones, si existe veremos algo asi:


Si no existe veremos algo asi:



Entonces será necesario instalarlo. Para ello teclearemos en la terminal:

sudo apt-get update

para obtener las listas actualizadas de los repositorios:


Despues teclearemos:

sudo apt-get install g++

y la instalacion comenzara. Cuando sea necesario presionamos Y


y dejamos que la instalación concluya. Después volveremos a teclear g++ para verificar que realmente se haya instalado con éxito:


EN ESTA ENTRADA PODRÁN VER UNA RESEÑA MUY COMPLETA HECHA POR MI SOBRE ÉSTE LENGUAJE: Click aqui!!

JAVA

Otro lenguaje muy completo y muy poderoso, utilizado muy ampliamente por desarrolladores de juegos y aplicaciones. Éste será el lenguaje que usaré para escribir mi proyecto.
Cuenta con muchos soportes técnicos (oficiales y no oficiales) muy completos en línea.

Cómo empezar

Para comenzar a utilizar Java necesitamos instalar el Java Development Kit (JDK), este incluye el compilador y el runtime para probar nuestras aplicaciones.
Para instalar esta herramienta teclearemos en la terminal:

sudo apt-get install openjdk-6-jdk

Verermos algo como esto:



Presionamos Y para aceptar la instalacion y esperamos a que ésta concluya.

Para verificar que se haya instalado con éxito tecleamos en la Terminal

javac

Lo que mostrara un texto parecido a ésto:


Tambien tecleamos

java

Con lo que veremos algo como esto:


Aquí pueden ver la documentación de JAVA 6: API

Herramientas

Diagramas UML

“ Es un lenguaje gráfico para visualizar, especificar, construir y documentar un sistema. UML ofrece un estándar para describir un "plano" del sistema (modelo), incluyendo aspectos conceptuales tales como procesos de negocio y funciones del sistema, y aspectos concretos como expresiones de lenguajes de programación, esquemas de bases de datos y componentes reutilizables.

Es importante resaltar que UML es un "lenguaje de modelado" para especificar o para describir métodos o procesos. Se utiliza para definir un sistema, para detallar los artefactos en el sistema y para documentar y construir. En otras palabras, es el lenguaje en el que está descrito el modelo.”

Fuente: http://es.wikipedia.org/wiki/Lenguaje_Unificado_de_Modelado

Los diagramas UML son muy útiles ya que nos ayudan a diseñar nuestro sistema por medio de una iinterfaz muy intuitiva. Cada una de nuestras las parte de nuestro programa es representada por medio de un nodo de un diagrama de árbol, y cada parte la podemos interconectar con otras con las cuales es necesario entablar comunicación. Una vez ensamblado nuestro sistema es posible generar el código del mismo en diversos lenguajes.

Podemos instalar diversas herramientas para generar diagramas UML, dos de ellas son Bouml y Umbrello

Instalar UMBRELLO

1. Entrar al menú APPLICATIONS
2. Entrar al programa UBUNTU SOFTWARE CENTER
3. En la ventana de UBUNTU SOFTWARE CENTER, teclear en la caja de busqueda "UMBRELLO"
4. Dar click en "INSTALL"


INTERFAZ

Instalar BOUML

1. Entrar al menú APPLICATIONS
2. Entrar al programa UBUNTU SOFTWARE CENTER
3. En la ventana de UBUNTU SOFTWARE CENTER, teclear en la caja de busqueda "BOUML"
4. Dar click en "INSTALL"


INTERFAZ



Espero les sirvan estas herramientas, en la barra de la derecha en "RECURSOS" hallaran muchas mas herramientas.

SALUDOS :)