miércoles, 23 de noviembre de 2011

Puntos Extras Taller Programación Orientada a Objetos

http://jviezca.blogspot.com/2011/08/ejemplo-moto.html
http://jviezca.blogspot.com/2011/09/interfaces-en-java.html

Puntos Extras Clase POO

http://jviezca.blogspot.com/2011/08/crisis-del-software-puntos-extras.html
http://jviezca.blogspot.com/2011/08/metodologias-para-el-analisis-y-diseno.html
http://jviezca.blogspot.com/2011/08/algunos-ejemplos-de-diagramas-de-casos.html
http://jviezca.blogspot.com/2011/09/ejercicio-1-relaciones-de-herencia.html
http://jviezca.blogspot.com/2011/09/ejercicio-2-algunos-conceptos.html
http://jviezca.blogspot.com/2011/09/caso-biblioteca-ejercicio-3.html
http://jviezca.blogspot.com/2011/09/diagrama-de-clases-en-umbrello.html
http://jviezca.blogspot.com/2011/11/antipatrones-de-diseno.html
http://jviezca.blogspot.com/2011/11/ejercicio-pruebas-unitarias.html
http://jviezca.blogspot.com/2011/11/puntos-extras-taller-poo.html

Tengo duda si esta entrada cuenta como puntos extras:
http://jviezca.blogspot.com/2011/09/tarjetas-crc.html

Ejercicio Interfaz Grafica y Heuristicas

Ejercicio Pruebas Unitarias

Ejercicio que consiste en hacer dos pruebas unitarias


Antipatrones de diseño


Los antipatrones de diseño son resultado de malas prácticas de programación e invariablemente conducen a una errónea solución a un problema.

Hay una gran cantidad de antipatrones. Yo me ocuparé solamente de algunos de ellos:
  
    Gran Bola de Lodo.
·         Reinventar la rueda.
·         Objeto Todopoderoso.
·         Código espagueti


Gran Bola de Lodo
Antipatrón de diseño de software que consiste en la realización de un programa sin una estructura clara y que por lo mismo resulta difícil de comprender. Los programadores suelen caer en esto debido a la falta de preparación  en análisis y diseño de sistemas.
El principal problema al hacer una aplicación de esta forma no es que no funcione sino el mantenimiento futuro que pueda necesitar el programa.


Reinventar la rueda
Antipatrón metodológico que se refiere al hecho de resolver un problema desde cero cuando ya hay soluciones a dicho problema. El punto aquí es no esforzarte de más por algo que ya se inventó.


Objeto Todopoderoso
Antipatrón en el que un objeto se encarga de hacer todo. La idea cuando un programador trata de resolver un gran problema es dividirlo en pequeños para ir resolviéndolos uno a uno y al final manejar esto como un todo. 


Código espagueti
Antipatrón muy similar al de “Gran Bola de Lodo” en el que se realiza un programa de gran extensión sin una estructura definida y que por esto resulta difícil comprender el código.


Fuentes 
1 

lunes, 31 de octubre de 2011

Patrones de diseño (Taller)

El patrón que estoy tratando de implementar en mi proyecto es el de Modelo-Vista-Controlador. 

A modo de ejemplo tomaré la función abrir. A continuación se puede apreciar como es que divide el código para manejar el patrón MVC.

Clase Interfaz

/** Clase que maneja la vista del editor
 * 
 * 
 * 
 * 
 * */ 

import java.awt.event.*;
import javax.swing.*;
import java.awt.*;

import javax.swing.text.*;

 public class Interfaz extends JFrame{

  JMenuBar barraMenu;
  JMenu archivo;
  JMenuItem abrirFichero;
  JMenuItem guardarFichero;
  JMenuItem salir;
  JMenu edicion;
  JMenuItem cortar;
  JMenuItem copiar;
  JMenuItem pegar;
     JTextArea areaDeTexto;
  JScrollPane desplazamiento;  
  
  // Constructor de la clase Interfaz. 
  public Interfaz(){

  super("Editor ++");
  this.setSize(400,400);
  this.definir_componentes();
  this.agregar_componentes();
  this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  this.setVisible(true);

  }

  /** Se definen los componentes de la ventana, así como también 
   * algunas de sus características
   * 
   * 
   * */
  public void definir_componentes(){
  
  // Área de Texto
  areaDeTexto = new JTextArea();
  areaDeTexto.setLineWrap(true);
  areaDeTexto.setWrapStyleWord(true);
  desplazamiento = new JScrollPane(areaDeTexto);

  // Barra de menú y menús
  barraMenu = new JMenuBar();
  archivo = new JMenu("Archivo");
  archivo.setMnemonic(KeyEvent.VK_A);
  edicion = new JMenu("Edición");
  edicion.setMnemonic(KeyEvent.VK_E);
 
  // MenuItems
  abrirFichero = new JMenuItem(new ModeloAbrir(areaDeTexto));
  guardarFichero = new JMenuItem(new ModeloGuardar(areaDeTexto));
  salir = new JMenuItem("Salir");
  
  
  Action accionCopiar = areaDeTexto.getActionMap().get(DefaultEditorKit.copyAction);
  accionCopiar.putValue(Action.NAME,"Copiar  ");
  accionCopiar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('C',Event.CTRL_MASK));
  copiar = new JMenuItem(accionCopiar);
  
  Action accionPegar = areaDeTexto.getActionMap().get(DefaultEditorKit.pasteAction);
  accionPegar.putValue(Action.NAME,"Pegar  ");
  accionPegar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('P',Event.CTRL_MASK));
  pegar = new JMenuItem(accionPegar);
  
  
  Action accionCortar = areaDeTexto.getActionMap().get(DefaultEditorKit.cutAction);
  accionCortar.putValue(Action.NAME,"Cortar  ");
  accionCortar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('O',Event.CTRL_MASK));
  cortar = new JMenuItem(accionCortar);
  
  
  }
  
  
  /** Agrega los componentes definidos por 
   * la función definir_componentes()
   * 
   * */
  
  public void agregar_componentes(){

   barraMenu.add(archivo);
   barraMenu.add(edicion);
   archivo.add(abrirFichero);
   archivo.add(guardarFichero);
   archivo.add(salir);
   edicion.add(copiar);
   edicion.add(pegar);
   edicion.add(cortar);
   this.add(barraMenu, BorderLayout.NORTH);
   this.add(desplazamiento, BorderLayout.CENTER);

   } 
 
}

Clase ModeloAbrir

/** Clase en la que se maneja la mayor parte de la lógica de la
 *  acción abrir del menú Archivo
 * 
 * 
 * */

import java.awt.Event;
import java.io.*;
import javax.swing.*;
import javax.swing.text.*;


// Clase ModeloAbrir que hereda de la clase abstracta ControladorAbrir
public class ModeloAbrir extends ControladorAbrir {

     /** Constructor de la clase ModeloAbrir
      * 
      *
      * @param areaDeTrabajo Componente en el que se pretende mostrar el
      * contenido del archivo leído.
      */
     public ModeloAbrir(JTextComponent areaDeTrabajo)
     {
      // Se le pasa al constructor de la superclase el JTextComponent
         super(areaDeTrabajo);
         
         // Etiqueta y tecla aceleradora
         this.putValue(Action.NAME, "Abrir ...");
         this.putValue(Action.ACCELERATOR_KEY,
             KeyStroke.getAWTKeyStroke('A', Event.CTRL_MASK));
     }
     

     /**
      * Lee el archivo y coloca su contenido en el área de texto
      *
      * @param archivo Archivo a leer
      *
      * @throws FileNotFoundException Error al leer el archivo
      */
     
     @Override
     protected void logicaAbrir(File archivo)
         throws FileNotFoundException
     {
      // Se crea el objeto archivoEntrada para leer el archivo.
      // bufferLinea irá modificando su longitud al ir leyendo las lineas del
      // archivo. Al final todos esos caracteres se colocarán en el area de Texto
         BufferedReader archivoEntrada = new BufferedReader(new FileReader(archivo));
         StringBuffer bufferLinea = new StringBuffer();

         try
         {
             String linea = archivoEntrada.readLine();

             while (linea != null)
             {
              //  Se va añadiendo las líneas que se leen a la variable bufferLinea
              //  modificando cada vez la longitud de caracteres de esta variable.
              // Además se agrega un salto de línea con la instrucción 
              // System.getProperty("line.separator") la cual da mayor portabilidad
                 bufferLinea.append(linea);
                 bufferLinea.append(System.getProperty("line.separator"));
                 
                 // Siguiente linea.
                 linea = archivoEntrada.readLine();
             }
         }
         catch (IOException e)
         {
             JOptionPane.showMessageDialog(
                 areaDeTrabajo, e, "Error al leer el archivo",
                 JOptionPane.ERROR_MESSAGE);
   
         }

         // Se pone el texto leido en el JTextArea.
         areaDeTrabajo.setText(bufferLinea.toString());
     }
 }
 

Clase ControladorAbrir

/** Clase que maneja el controlador de la acción abrir del menú

 *  Archivo

 * 

 * 

 * */



import java.awt.event.ActionEvent;

import java.io.*;

import javax.swing.*;

import javax.swing.text.JTextComponent;



public abstract class ControladorAbrir extends AbstractAction{



    protected JTextComponent areaDeTrabajo;
  

    private JFileChooser fc;



    /** Constructor de la clase ControladorAbrir.

     * 

     *

     *  @param areaDeTrabajo Componente de texto en el cual se mostrará

     *  el contenido del archivo

     * 

     */

    public ControladorAbrir(JTextComponent areaDeTrabajo)

    {

        this.areaDeTrabajo = areaDeTrabajo;  
    }



    

    /** Método que se dispara cuando se da clic en la opción Abrir

     *

     *  @param event 

     */

    public void actionPerformed(ActionEvent event)

    {

     // Se crea el FileChooser.

        fc = new JFileChooser();

    
        int respuesta;


        respuesta = fc.showOpenDialog(areaDeTrabajo);


        //  Confirma que se haya presionado el botón Abrir y así poder aplicar

        // la lógica de la opción Abrir

        if (JFileChooser.APPROVE_OPTION == respuesta)

        {
         // Se obtiene el fichero

         File archivo = fc.getSelectedFile();
            try

            {

             //  Se abre el archivo. Este método tiene que ser definido por las

             // clases hijas

                logicaAbrir(archivo);

            }
            catch (Exception e)
            {

             // Mensaje de error si se produce.

                JOptionPane.showMessageDialog(

                    areaDeTrabajo, e, "Error en el archivo " + archivo,

                    JOptionPane.ERROR_MESSAGE);

            }

        }

    }



    /** Las clases hijas deben redefinir este método abstracto para leer el contenido 

     *  del archivo

     *

     * @param archivo Archivo del cual se va a leer

     *

     * @throws FileNotFoundException Excepción si el archivo no existe.

     */

    protected abstract void logicaAbrir(File archivo)

        throws FileNotFoundException;

}







Enseguida también pongo el código como separé la funcionalidad "Guardar como...".




La parte de Interfaz es la misma que la mostrada en el ejemplo anterior.


Clase ModeloGuardar


/** Clase en la que se maneja la mayor parte de la lógica de la
 *  acción guardar del menú Archivo
 * 
 * 
 * 
 * 
 * */


import java.awt.Event;
import java.io.*;

import javax.swing.*;
import javax.swing.text.*;


//Clase ModeloGuardar que hereda de la clase abstracta ControladorGuardar
public class ModeloGuardar extends ControladorGuardar
{
   

 /** Constructor de la clase ModeloGuardar
     * 
     *
     * @param areaDeTrabajo Componente en el que se pretende tomar el contenido 
     *  para guardarlo en alguna ruta en específico
     */
    public ModeloGuardar(JTextComponent areaDeTrabajo)
    {
     // Se le pasa al constructor de la superclase el JTextComponent
        super(areaDeTrabajo);
        
        // Etiqueta y tecla aceleradora
        this.putValue(Action.NAME, "Guardar como...  ");
        this.putValue( Action.ACCELERATOR_KEY,
            KeyStroke.getAWTKeyStroke('G', Event.CTRL_MASK));
    }

    /** Toma el archivo creado de la ruta específicada en el selector de archivos
     * y escribe sobre él el contenido del areaDeTrabajo (área de Texto) para
     * guardarlo en dicho archivo
     *
     * @param archivo Archivo a escribir
     *
     * @throws FileNotFoundException Error al leer el archivo
     */
    protected void logicaGuardar(File archivo) throws FileNotFoundException
    {
        PrintWriter archivoSalida = new PrintWriter(archivo);
        archivoSalida.print(areaDeTrabajo.getText());
        archivoSalida.close();
    }
}

 

Clase ControladorGuardar


/** Clase que maneja el controlador de la acción guardar del menú
 *  Archivo
 * 
 * 
 * */

import java.awt.event.ActionEvent;
import java.io.*;

import javax.swing.*;
import javax.swing.text.JTextComponent;


public abstract class ControladorGuardar extends AbstractAction
{
   
    protected JTextComponent areaDeTrabajo;

    
    private JFileChooser selectorArchivos;

  
    

    

    /** Constructor de la clase ControladorGuardar
     * 
     *
     *  @param componenteTexto Componente de texto del cual se dispondrá de
     *  su contenido para guardarlo
     * 
     */
    public ControladorGuardar( JTextComponent areaDeTrabajo)
    {
        this.areaDeTrabajo = areaDeTrabajo;
        
    }


    /** Método que se dispara cuando se da clic en la opción Guardar
    *
    *  @param event 
    */
    public void actionPerformed(ActionEvent event)
    {   
        
        selectorArchivos = new JFileChooser();
        int respuesta;

        respuesta = selectorArchivos.showSaveDialog(areaDeTrabajo);
        

        //  Confirma que se haya presionado el botón Guardar y así poder aplicar
        // la lógica de la opción Guardar
        if (JFileChooser.APPROVE_OPTION == respuesta)
        {
         // Se obtiene el fichero
            File archivo = selectorArchivos.getSelectedFile();

            try
            {
             // Se guarda. Las clases hijas deben redefinir este método.
                logicaGuardar(archivo);
            }
            catch (Exception e)
            {
             // Mensaje de error si se produce.
             JOptionPane.showMessageDialog(null,"Error de archivo"+e.toString());
            }
        }
    }

    
    /** Las clases hijas deben redefinir este método abstracto para guardar el contenido 
     *  
     *
     * @param archivo Archivo en el cual se va a guardar
     *
     * @throws FileNotFoundException Excepción si el archivo no existe.
     */
    protected abstract void logicaGuardar(File archivo)throws FileNotFoundException;
}


Fuentes
Chuidiang

Patrones de diseño (Clase)

El patrón de diseño o arquitectura que identifiqué podría encajar adecuadamente en el proyecto que estoy realizando es el MVC (Modelo-Vista-Controlador). Desde un principio he estado tratando separar, aún sin el conocimiento del patrón MVC, la interfaz de la parte lógica. Sin embargo al enterarme de la existencia del patrón antes mencionado, me enfoqué a adaptar mi sistema a esa estructura debido a que era la que desde un principio más o menos venía implementando, exceptuando la parte de tratar por separado al controlador. Pienso que aplica muy bien ya que puedo manejar tareas por separado y por lo tanto probarlas individualmente.Otra razón por la que decidí seguir con ese diseño fue la simpleza con la que se me permite agregar nuevas funcionalidades a los menús. Al principio tuve algunas dificultades para unir las partes separadas pero después de un rato pude encontrar respuestas en algunas fuentes de Internet.


Aunque ya esté trabajando con el MVC, no descarto que se puedan utilizar otros patrones de diseño, tal es el caso del patrón Builder que consiste en hacer objetos complejos a partir de un solo punto o clase, tal y como pienso podría aplicar en mi software. Habría que checar bien si es que se puede adaptar algún otro más. 

En la siguiente entrada se presenta código en el cual se visualiza la forma como aplico el MVC.


Interfaz Gráfica (Taller)

A continuación se muestra la ventana inicial con la que cualquier usuario del software tendrá que interactuar. A simple vista se nota la presencia de una barra de menús y dos menús, uno llamado “Archivo” y el otro “Edición”.



En esta segunda vista se observan las opciones del menú Archivo, las cuales son Abrir, Guardar como… y Salir. También se pueden apreciar las teclas aceleradoras para cada uno de los MenuItems.




Y por último y de igual manera que en la segunda, en la tercera se visualizan  las opciones del menú Edición, junto con sus respectivos shortcuts.






Quizás ésta no sea la interfaz final ya que pienso agregar algunas cosas más.

jueves, 20 de octubre de 2011

Interfaz Gráfica (Clase)

Enseguida muestro la interfaz que desde un inicio me planteé hacer para mi proyecto.
Interfaz gráfica inicial
View more presentations from Jair Viezca

Como se puede apreciar en la filmina #2, la interfaz consiste básicamente en una gran área de trabajo, una barra de menús con sus respectivos menús (Archivo, Edición, Formato, Ayuda) y una barra de herramientas con su grupo de iconos que representan funcionalidades del sistema (Nuevo, Copiar, Cortar, Negrita, Cursiva). En la parte inferior de la pantalla pienso colocar una barra de estado en el que se indiqué en que documento se está.


El contenido de los menús también lo puse para dejar más o menos en claro que es lo que deseo poner en cada uno de ellos.


Por si existe algún problema para ver el slideshare, dejaré las imágenes correspondientes a la interfaz. Además subiré el dibujo con el que empecé a planear mi interfaz.










En la siguiente filmina se puede observar a detalle cada una de las opciones que pienso colocar en cada uno de los menús. 

Eventos, excepciones y errores (Taller)

El proyecto que estoy llevando a cabo consiste actualmente en cinco clases: Interfaz, ModeloAbrir, ControladorAbrir, ModeloGuardar, ControladorGuardar; algunas de las cuales cuentan con eventos (especialmente los controladores) y con excepciones.



Eventos

ControladorAbrir

Esto es lo que pasa cuando presiono el botón Abrir del menú Archivo






public void actionPerformed(ActionEvent event)
    {
     // Se crea el FileChooser.
        fc = new JFileChooser();
        
      
        int respuesta;

      
        respuesta = fc.showOpenDialog(areaDeTrabajo);
        

        //  Confirma que se haya presionado el botón Abrir y así poder aplicar
        // la lógica de la opción Abrir
        if (JFileChooser.APPROVE_OPTION == respuesta)
        {
         
         // Se obtiene el fichero
         File archivo = fc.getSelectedFile();
         
            try
            {
             
                
             //  Se abre el archivo. Este método tiene que ser definido por las
             // clases hijas
                logicaAbrir(archivo);
            }
            catch (Exception e)
            {
             // Mensaje de error si se produce.
                JOptionPane.showMessageDialog(
                    areaDeTrabajo, e, "Error en el archivo " + archivo,
                    JOptionPane.ERROR_MESSAGE);
            }
        }
    }
 


ControladorGuardar

Esto es lo que pasa cuando presiono el botón Guardar del menú Archivo





public void actionPerformed(ActionEvent event)
    {   
        
        selectorArchivos = new JFileChooser();
        int respuesta;

        respuesta = selectorArchivos.showSaveDialog(areaDeTrabajo);
        

        //  Confirma que se haya presionado el botón Guardar y así poder aplicar
        // la lógica de la opción Guardar
        if (JFileChooser.APPROVE_OPTION == respuesta)
        {
         // Se obtiene el fichero
            File archivo = selectorArchivos.getSelectedFile();

            try
            {
             // Se guarda. Las clases hijas deben redefinir este método.
                logicaGuardar(archivo);
            }
            catch (Exception e)
            {
             // Mensaje de error si se produce.
             JOptionPane.showMessageDialog(null,"Error de archivo"+e.toString());
            }
        }
    }
 




Copiar, cortar y pegar del menú Edición

Para estas opciones no fue necesario implementar la interfaz ActionListener y su respectivo método abstracto public void actionPerformed(ActionListener arg0) debido a que ya puedo encontrar las acciones en la biblioteca de Java, más en específico de DefaultEditorKit el cual se puede encontrar en la librería javax.swing.text. Para hacer lo anterior (y como se puede apreciar en el código) primero debemos obtener el mapa de acciones del área de Texto para poder agregar las acciones (copiar, cortar y pegar) a los MenuItems y llevarlas a cabo dentro de dicha área. Lo que habría que checar es si es posible realizar dichas acciones en otros componentes de Texto (JEditorPane, JTextPane).


Action accionCopiar = areaDeTexto.getActionMap().get(DefaultEditorKit.copyAction);
accionCopiar.putValue(Action.NAME,"Copiar  ");
accionCopiar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('C',Event.CTRL_MASK));
copiar = new JMenuItem(accionCopiar);

Action accionPegar = areaDeTexto.getActionMap().get(DefaultEditorKit.pasteAction);
accionPegar.putValue(Action.NAME,"Pegar  ");
accionPegar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('P',Event.CTRL_MASK));
pegar = new JMenuItem(accionPegar);


Action accionCortar = areaDeTexto.getActionMap().get(DefaultEditorKit.cutAction);
accionCortar.putValue(Action.NAME,"Cortar  ");
accionCortar.putValue(Action.ACCELERATOR_KEY,KeyStroke.getAWTKeyStroke('O',Event.CTRL_MASK));
cortar = new JMenuItem(accionCortar);
 


Excepciones y errores

ModeloAbrir

Se presentan dos excepciones en esta parte del código.

1.- Se arroja la excepción FileNotFoundException cuando no se puede encontrar el archivo.

2.- En el try-catch, el catch y IOException se emplean cuando existe un error de lectura.



protected void logicaAbrir(File archivo)
         throws FileNotFoundException
     {
      // Se crea el objeto archivoEntrada para leer el archivo.
      // bufferLinea irá modificando su longitud al ir leyendo las lineas del
      // archivo. Al final todos esos caracteres se colocarán en el area de Texto
         BufferedReader archivoEntrada = new BufferedReader(new FileReader(archivo));
         StringBuffer bufferLinea = new StringBuffer();

         try
         {
             String linea = archivoEntrada.readLine();

             while (linea != null)
             {
              //  Se va añadiendo las líneas que se leen a la variable bufferLinea
              //  modificando cada vez la longitud de caracteres de esta variable.
              // Además se agrega un salto de línea con la instrucción 
              // System.getProperty("line.separator") la cual da mayor portabilidad
                 bufferLinea.append(linea);
                 bufferLinea.append(System.getProperty("line.separator"));
                 
                 // Siguiente linea.
                 linea = archivoEntrada.readLine();
             }
         }
         catch (IOException e)
         {
             JOptionPane.showMessageDialog(
                 areaDeTrabajo, e, "Error al leer el archivo",
                 JOptionPane.ERROR_MESSAGE);
   
         }

         // Se pone el texto leido en el JTextArea.
         areaDeTrabajo.setText(bufferLinea.toString());
     }
 }
 


ControladorAbrir

Excepción para cuando existan errores al abrir el archivo

// Se crea el FileChooser.
        fc = new JFileChooser();
        
      
        int respuesta;

      
        respuesta = fc.showOpenDialog(areaDeTrabajo);
        

        //  Confirma que se haya presionado el botón Abrir y así poder aplicar
        // la lógica de la opción Abrir
        if (JFileChooser.APPROVE_OPTION == respuesta)
        {
         
         // Se obtiene el fichero
         File archivo = fc.getSelectedFile();
         
            try
            {
             
             
             //  Se abre el archivo. Este método tiene que ser definido por las
             // clases hijas
                logicaAbrir(archivo);
            }
            catch (Exception e)
            {
             // Mensaje de error si se produce.
                JOptionPane.showMessageDialog(
                    areaDeTrabajo, e, "Error en el archivo " + archivo,
                    JOptionPane.ERROR_MESSAGE);
            }
        }
 


ModeloGuardar

Excepción utilizada para saber avisar que se ha producido errores al momento de guardar.



selectorArchivos = new JFileChooser();
        int respuesta;

        respuesta = selectorArchivos.showSaveDialog(areaDeTrabajo);
        

        //  Confirma que se haya presionado el botón Guardar y así poder aplicar
        // la lógica de la opción Guardar
        if (JFileChooser.APPROVE_OPTION == respuesta)
        {
         // Se obtiene el fichero
            File archivo = selectorArchivos.getSelectedFile();

            try
            {
             // Se guarda. Las clases hijas deben redefinir este método.
                logicaGuardar(archivo);
            }
            catch (Exception e)
            {
             // Mensaje de error si se produce.
             JOptionPane.showMessageDialog(null,"Error de archivo"+e.toString());
            }
        }
 


Fuentes
Chuidiang

Eventos, excepciones y errores (Clase)

Eventos


Excepciones y Errores

En la siguiente entrada se podrán ver códigos en donde manejo estos eventos, excepciones y errores. Cabe mencionar que estos eventos, excepciones y errores son los más importantes.

Diagramas de secuencia para mi proyecto

Para realizar los diagramas de secuencia que se presentarán a continuación hice uso de un recurso web localizado en la página http://www.websequencediagrams.com/.

Los diagramas de secuencia los hice en base a dos casos de uso: el de abrir y guardar archivo. En cada uno de ellos simule una situación exitosa y una fallida.

Caso de uso: Abrir Archivo





Caso de uso: Guardar Archivo




Diagramas de secuencia


Hay una gran variedad de diagramas que se pueden hacer para nuestros proyectos de POO, como lo son los de Casos de Uso, los de Clases, los de Objetos, etc. Ahora toca el turno de “hablar” acerca de los Diagramas de Secuencia, que forman parte de cualquier trabajo bien hecho.

Como ya se vio en entradas pasadas, un recurso de modelación  que se podría usar para hacer este tipo de diagramas es el Umbrello, el cual es una herramienta CASE que no sólo nos permite hacer estos diagramas sino otros más.
Los diagramas de secuencia muestran la forma como se comunican los objetos entre sí al ejecutarse un programa o un caso de uso de éste. Ésta representación se hace por medio de un conjunto de símbolos, algunos de los cuales son:



Ejemplos




Diagramas de secuencia actividad
View more presentations from Jair Viezca

Fuentes
1
2
3
4

jueves, 29 de septiembre de 2011

Tarjetas CRC

  • Son una metodología para el diseño de programas orientados a objetos.
  • CRC son las iniciales de clase, responsabilidad y colaboración.
  • Resumen las responsabilidades de una clase antes de pasar a realizar el diagrama.
  • Sirven para simular escenarios.

Las tarjetas CRC representan objetos; la clase a la que pertenece el objeto se puede escribir arriba, las responsabilidades u objetivos que debe llevar a cabo el objeto se pueden escribir a la izquierda, y la derecha las clases que se relacionan con dicho objeto.



Tarjetas CRC de mi Proyecto





Documentación técnica en mi proyecto

Ya se vio la importancia de la documentación. Procederé a considerarla en mi proyecto para lo cual utilizaré el código generado a partir del diagrama de clases que hice.


Primero comentarizo mis clases.




Clase Interfaz


/**
* Clase que crea la interfaz del editor y 
  recibe las acciones de las clases con las 
  que se relaciona para sus menús.
*
* @author Jair Viezca Esparza.
*
* Fecha de creación: 17 de Septiembre del 2011.
*
* Última actualización: 26 de Septiembre del 2011.
*/

import java.util.*;


/**
 * Clase Interfaz
 */
public class Interfaz {

  //
  // Fields
  //

  
  /**
  * Constructor de la clase interfaz
  */
  public Interfaz () { };
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  //
  // Other methods
  //

}


Clase accionesArchivo

/**
* Clase que define algunas de las acciones básicas del menú archivo
*
* @author Jair Viezca Esparza.
*
* Fecha de creación: 17 de Septiembre del 2011.
*
* Última actualización: 26 de Septiembre del 2011.
*/

import java.util.*;


/**
 * Clase accionesArchivo
 */
public class accionesArchivo {

  //
  // Fields
  //

  
  /**
  // Constructor de la clase 
  */
  public accionesArchivo () { };
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  //
  // Other methods
  //

  /**
   * Método que realiza todo el proceso funcional de el menú archivo. El parámetro
     event se utiliza para manejar las acciones de los menuitems
   * @param event
   */
  public void actionPerformed( ActionEvent event )
  {
  }


}


Clase accionesEdicion

/**
* Clase que define algunas de las acciones básicas del menú edición
*
* @author Jair Viezca Esparza.
*
* Fecha de creación: 17 de Septiembre del 2011.
*
* Última actualización: 26 de Septiembre del 2011.
*/

import java.util.*;


/**
 * Clase accionesEdicion
 */
public class accionesEdicion {

  //
  // Fields
  //

  
  /**
  // Constructor de la clase
  */
  public accionesEdicion () { };
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  //
  // Other methods
  //

  /**
   * Método que realiza todo el proceso funcional de el menú edición. El parámetro
     event se utiliza para manejar las acciones de los menuitems
   * @param event
   */
  public void actionPerformed( ActionEvent event )
  {
  }


}


Clase accionesFormato

/**
* Clase que define algunas de las acciones básicas del menú formato
*
* @author Jair Viezca Esparza.
*
* Fecha de creación: 17 de Septiembre del 2011.
*
* Última actualización: 26 de Septiembre del 2011.
*/

import java.util.*;


/**
 * Clase accionesFormato
 */
public class accionesFormato {

  //
  // Fields
  //

  
  //
  // Constructor de la clase
  //
  public accionesFormato () { };
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  //
  // Other methods
  //

  /**
   * Método que realiza todo el proceso funcional de el menú formato. El parámetro
     event se utiliza para manejar las acciones de los menuitems
   * @param event
   */
  public void actionPerformed( ActionEvent event )
  {
  }


}




Después me ubico en la carpeta en donde tengo mis archivos de código.

Mi carpeta inicial

Posteriormente entro al cmd y me dirijo hacia esa carpeta. Una vez ahí escribo el siguiente comando:

javadoc *.java

lo cual tomará todos esos comentarios escritos entre /** y */ de los documentos con extensión java, y creará los archivos con formato HTML ya sea en la misma carpeta o en otra donde se requiera.

Ejecución del javadoc


Mi carpeta después de javadoc


De todos esos archivos HTML el más importante es el index, así que lo abrí con Mozilla Firefox  y listo.

Documentación de mi proyecto


Esto es muy bueno ya que le da más formalidad al trabajo.

Importancia de la documentación técnica

¿Qué es la documentación técnica? Documentar es agregar cierta información al código que nos permitirá conocer detalles importantes de éste y con lo cual se espera  tener mayor facilidad a la hora de leer las instrucciones de la aplicación ya sea por parte del creador o por otra persona.

La documentación no es un lujo(*) sino una necesidad por lo tanto, es sumamente importante de considerar a la hora de hacer un software, ya que es común que los programas sufran cambios a lo largo de su “vida” al adaptarse a nuevos escenarios, por lo tanto poner líneas  con esta información ayudará a repararlo y modificarlo.
(*) Con lujo me refiero a que sea algo de más, algo de adorno.

Ejemplo de aplicación de documentación técnica  tomado de  http://es.wikipedia.org/wiki/Javadoc



¿Y qué es lo que comúnmente se documenta? Comenzar documentando el propósito del software, el desarrollador y la fecha de creación no sería una mala idea. Tampoco lo sería comentar la funcionalidad de cada uno de los métodos o clases. Todo comentario es bien recibido siempre y cuando aporte.  

La documentación bien podría hacerse sólo en el código y ya, sin embargo esto no sería del todo adecuado teniendo herramientas que permiten manejar toda la documentación en un sitio aparte de una forma clara y ordenada.

Hay decenas de generadores de documentación (Sandcastle, NDdoc, Doxygen, Natural Docs), cada uno con sus requerimientos y especificaciones, sin embargo me centraré en javadoc ya que es el que voy a utilizar para mi proyecto.



Javadoc

Es un recurso de Oracle que nos permite generar la documentación en formato HTML de una aplicación en Java.

Dentro de un código, Javadoc toma aquellos comentarios que cuentan con las marcas especiales especificadas por dicho programa y construye un archivo HTML en el que se maneja toda esa información como toda la documentación estándar de Java provista por SUN.

He aquí el API de Java  provista por Oracle. Éste es un claro ejemplo de cómo se generaría su documentación.



¿Y cuáles son esas marcas especiales?

Javadoc toma en consideración aquellos comentarios que empiecen con /**  y terminen con  */, por lo tanto todo lo que escribamos dentro de esos signos será material de trabajo para Javadoc. A la vez, dentro de estos comentarios podremos utilizar instrucciones HTML y ciertas palabras reservadas generalmente precedidas del “@”, y que son muy útiles para la documentación de datos relevantes.

A continuación se presentarán algunas de las palabras reservadas comúnmente utilizadas:



Una vez expuestos los identificadores se podrá ser capaz de entender el ejemplo mostrado en la parte superior de esta entrada.


¿Cómo se consigue Javadoc?

Javadoc viene incluido en el JDK.

He aquí la liga para descargar el Java Development Kit en caso de no contar con éste.

También se puede descargar de forma aislada en este link:



¿Cómo se ejecuta Javadoc?

Javadoc se ejecuta simplemente haciendo uso de estas líneas en el cmd:

javadoc [paquete] archivo.java, ...

Al  momento de hacer lo anterior se crearán todos los files HTML así que hay que cerciorarse de generarlos en una carpeta aparte para que no se mezclen con los files del código.



FUENTES