Max Hernandez

Laberinto - Ejemplo de Canvas en HTML5

viernes, 13 de mayo de 2011

Implementación de interfaces gráficas (tall)

Buen día.

Esta semana estamos tocando el tema de interfaces gráficas asi que voy a intentar explicar como funciona la parte grafica de mi proyecto para esto pondré partes del código y abajo un link al código por si alguien encuntra algo que le interese para su proyecto.

Bien para empezar explicare la estructura de clases de mi programa respecto a la interfaz gráfica. Para no tener problemas con esta parte del programa al empezar a diseñarlo incluí una clase dedicada a la interfaz gráfica que es la clase GUI pero no es suficiente explicar esta por que no es la unica clase que interactua directamente con el usuario y ademas de que tenia que saber la forma adecuada.

Las dos clases que interactuan directamente con el usuario son la clase Sheet y GUI. La primera se encarga de desplegar en pantalla el campo de trabajo para el texto, cuando el usuario abre un archivo el texto se muestra en esta área y hace posible la edición del texto por el usuario. La segunda clase se encarga de implementar los menús, La pantalla, información de ejecución y casi cualquier cosa de la interfaz de la cual no se encarga la clase Sheet.


La todos los componentes se agregan al JFrame que se encuentra en la clase GUI y eso me dio problemas con la clase Sheet puesto que esa interactúa directamente con la clase TextManager así que es implementada ahí pero es agregada a la ventana en GUI entonces para arreglar esto las dos clases comparten un JTabbedPane que me sirve como lista para agregar los Sheet de cada archivo que se abra ademas que permite cierta interacción entre la clase GUI y TextManager.

Para poder trabajar fácilmente con los archivos de cada hoja agregada al componente JTabbedPane hice una clase que junta la hoja de trabajo, el archivo y el nombre  del archivo. Esta clase es heredada de la clase JScrollPane asi cuando el usuario quiera guardar un archivo o cerrarlo o hacer cualquier cambie al archivo, el programa solo tiene que devolver el Tab con el que se trabaja actualmente para realizar cualquiera de esas acciones.


La clase GUI se encarga de desplegar los menús en la pantalla así como mostrar información de el programa y es hija de la clase JTextPane. Los componentes implementados aqui son:
  • JFrame que es la clase que se hereda para crear esta.
  • JPanel sirve como contenedor de otros componentes o como fondo del programa.
  • JMenuBar permite crear un menú desplegable.
  • JMenu permite agregar elementos que despliegan listas de botones al JMenuBar .
  • JMenuItem permite agregar botones al JMenuBar.
  • JSeparator es una linea que separa unos botones de otros en el JMenuBar.
  • JLabel un componente despliega texto o imágenes.


package mxText;

public class GUI extends javax.swing.JFrame{

private int numerodeBotones;
private static GUI instancia = null;
private Sheet texto;
JPanel p1, p2, p3;
JMenuBar barraMenu;
static JLabel label= new JLabel("");
String[] jMenu={"Archivo","Editar","Abrir","Nuevo","Guardar","Guardar Como"};

private GUI(String titulo, JTabbedPane tabs){
	super(titulo);
	super.setTitle(titulo);
	super.setLocation(0,0);
	super.setSize(500,500);
	super.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	super.setLayout(new BorderLayout());
	p1 = new JPanel();
	p2 = new JPanel();
	super.add(p1,BorderLayout.CENTER);
	p1.setLayout(new BorderLayout());
	this.texto = texto;	
	//JScrollPane scrollb = new JScrollPane(this.texto);
	//JTabbedPane tabs = tabs;
	p1.setPreferredSize(new Dimension(20,5));
	barraMenu = new JMenuBar();
	super.add(p2,BorderLayout.NORTH);
	super.add(label,BorderLayout.SOUTH);
	super.setJMenuBar(barraMenu);
	//tabs.addTab("archivo 1",scrollb);
	p1.add(tabs, BorderLayout.CENTER);
	super.setVisible(true);
}


/**
* Es la clase que prepara todos los componentes para e imprime en la pantalla.
*/
public void barraPrincipal(TextManager listener){
JMenu archivo = new JMenu(jMenu[0]);
JMenu editar = new JMenu(jMenu[1]);
JMenu buscar = new JMenu("Buscar");
barraMenu.add(archivo);
barraMenu.add(editar);
barraMenu.add(buscar);
JMenuItem abrir = new JMenuItem(jMenu[2]);
JMenuItem nuevo = new JMenuItem(jMenu[3]);
JMenuItem guardar = new JMenuItem(jMenu[4]);
JMenuItem guardarComo = new JMenuItem(jMenu[5]);
JMenuItem buscari = new JMenuItem("Buscar");
JMenuItem remplazar = new JMenuItem("Remplazar");
abrir.addActionListener(listener);
abrir.setActionCommand("abrir");
nuevo.addActionListener(listener);
nuevo.setActionCommand("nuevo");
guardar.addActionListener(listener);
guardar.setActionCommand("guardar");
guardarComo.addActionListener(listener);
guardarComo.setActionCommand("guardarComo");
buscar.add(buscari);
buscar.add(remplazar);
archivo.add(nuevo);
archivo.add(abrir);
archivo.add(new JSeparator());
archivo.add(guardar);
archivo.add(guardarComo);
}

};


La clase Sheet muestra el area de trabajo para mostrar y editar el texto de un archivo.Los componentes implementados aqui son:

  • JTextPane es el área utilizada para trabajar con el texto.
  • CaretUpdate un escuchador que se activa cada que se mueve el caret de el JTextPane
  • ScrollBar dibuja una barra para que se pueda mostrar todo el contenido del JTextPane.


package mxText;
import javax.swing.*;
import javax.swing.text.*;
import java.awt.Color;
import java.util.Hashtable;
import javax.swing.event.*;
/**
* Esta clase es una extencion de una herramienta que sirve de interfaz
* entre el usuario y el programa. Es una area donde se ingresa y se edita 
* el texto de archivos.
*@author Max Hernandez
*/
class Sheet extends javax.swing.JTextPane implements CaretListener { // Una pare de la interfaz grafica y sabe estructurar el texto en la pantalla

Hashtable colores = new Hashtable();
StyleContext sc = new StyleContext();
DefaultStyledDocument doc = new DefaultStyledDocument(sc);
JTextPane pane = new JTextPane(doc);

public void caretUpdate(CaretEvent e){
String[] lista = {"int","null","void","extends","implements"};
int valores[] = this.procesadorColumnas(super.getCaretPosition());
System.out.println("Ln "+valores[0]+" Col "+valores[1]);
GUI.label.setText("Ln "+valores[0]+" Col "+valores[1]);
}

public Sheet(){
super();
super.addCaretListener(this);
} 

private void anadirColor(String colorString, Color colorAwt ){
Style color = sc.addStyle("ConstantWidth", null);
StyleConstants.setForeground(color, colorAwt);
colores.put(colorString, color);
}

private int[] procesadorColumnas(int n){
String text1 = super.getText();
char text[] =text1.toCharArray();
int cont=0, valores[]={0,0};
for(int i=0;i

Saludos.

martes, 10 de mayo de 2011

Diseño de interfaces gráficas (clase)

Buen día.

Esta semana nos toco ver en clase el tema de las interfaces gráficas primero empezare explicando que es:
Una interfaz gráfica es un grupo de imágenes y objetos gráficos, estos gráficos representan información u operaciones y permiten una sencilla interacción entre el usuario y el programa.

Puesto que el software del proyecto estoy fabricándolo en java voy a hablar de las herramientas que java nos provee para realizar esta tarea.

Los paquetes AWT y Swing.
El lenguaje java nos proporciona los paquetes AWT y Swing para construir interfaces graficas en nuestros programas, El paquete AWT contiene clases para:


  • Reaccionar con las diferentes interacciones del usuario con el programa los cuales son los manejadores de eventos
  • Herramientas para dibujar objetos en la pantalla
  • Cambiar el color de los elementos dibujados
  • Trabajar con fuentes
  • Trabajar con imágenes.


El paquete Swing nos ofrece herramientas mas especificas para trabajar con la interfaz gráfica como son:


  • Trabajar con bordes.
  • Trabajar con ventanas que sirven para selección de colores, archivos.
  • Trabajar con eventos de componentes específicos como del teclado, de componentes de texto, del ratón.
  • Trabajar con tablas.
  • Trabajar con componentes de texto.
  • Trabajar con menús.


Esta imagen muestra la jerarquia de clases y componentes del paquete swing.

(imagen obtenida de "http://jroller.com/DhilshukReddy/resource/JavaSwing/JavaSwingCompoentsList.PNG")


Diseño del proyecto
Bien para mi diseño esta era mi idea para el proyecto, una ventana, en el centro un área donde se muestra   el texto del archivo para editarse. En la parte superior un menú con las opciones para darle formato al texto, abrir, cerrar y guardar archivos, para buscar palabras o partes del programa, etc.
tambien debía tener un área arriba para separar los archivos abiertos y un área donde se mostrara el proyecto en el que se trabaja actualmente.


y esta es la version actual de la interfaz



Los componentes utilizados para crear la interfaz gráfica son los siguientes

  • JFrame para dibujar la ventana.
  • JPanel
  • BorderLayout
  • FLowLayout
  • JMenuBar para dibujar la barra de menú superior que contiene los menús.
  • JMenu son los menús de opciones contenidos en el JMenuBar al dar click sobre ellos se despliega un submenu
  • JMenuItem son los botones que se muestran en el JMenu.
  • JTextPane es el área donde se muestra y edita el texto.
  • JLabel que muestra etiquetas dentro de los componentes.




Layouts
Para acomodar de forma que mas nos guste los componentes en java utilizamos los Layouts y aquí las características de algunos:

  • FlowLayout el cual acomoda los componentes en el orden en el que se agregan al contenedor de izquierda a derecha en forma horizontal.
  • BoxLayout al igual que el FlowLayout acomoda los componentes en el orden que se agregan pero de norte a sur y en forma vertical.
  • BorderLayout en este se acomodan los componentes como en puntos cardinales(norte, sur, este y oeste) y al centro.
  • GridLayout en este caso se crean celdas y se agregan componentes en la celda especificada.
  • GridBagLayout es igual que el anterior se crean celdas de NxN pero en este los componentes pueden ocupar varias celdas horizontal y verticalmente. 



(imagen obtenida de "http://javafaq.nu/img/java_lectures/mt1420-2003-2004-lecture16-14_1.jpg")

Para el proyecto solo utilice un BorderLayout en la forma que se muestra en la imagen el norte el JMenuBar, al centro el JTabbedPane y al sur un JLabel.




Saludos.

jueves, 14 de abril de 2011

Implementación de pruebas unitarias

Buen día.

Bueno para esta publicación me toca presentar las pruebas unitarias que implemente para mi proyecto las cuales son las siguientes :


Prueba Writer
Para realizar esta prueba utilice un archivo de texto llamado "ejemplo.txt" con este archivo en el método prueba cree dos objetos de este a partir del archivo, uno de los objetos lo sobrescribí con el contenido del archivo "ejemplo.txt" y el otro lo deje igual. Al comparar me dirían si el contenido del archivo se recuperaba exitosamente o si la clase tenia errores.

Este es el código de la prueba:
package pruebas;

import java.io.*;
import java.lang.StringBuffer;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;

public class PruebaWriter extends TestCase {

    protected Writer w;
    private File prueba;
    private File secundario;
    private StringBuffer buffer = new StringBuffer();
    
    protected void setUp() {
 try{
     this.prueba = new File("ejemplo.txt");
     this.secundario = new File("ejemplo.txt");
     this.w = new Writer("",secundario,buffer);
 }catch(Exception e){
     e.printStackTrace();
 }
 return;
    }
    
    public static Test suite() {
 return new TestSuite(PruebaWriter.class);
    }

    public void testEscribiendo() {
 System.out.println("Escribiendo Documento...");
 buffer.append("Su hermano fue en su busca, a tierras muy lejanas.");
 w.escribirDocumento();
 w.cerrarArchivo();
 super.assertEquals(secundario,prueba);
 return;
    }

    public static void main(String[] args) {
 TestRunner.run(PruebaWriter.suite());
 return;
    }
}

Prueba Reader
Para comprobar el correcto funcionamiento de esta clase utilice un archivo de prueba llamado "ejemplo.txt" leyendo el contenido por medio de la clase Reader y después pasándolo a un String me fue mas fácil comparar ese String con otro que yo hice donde estaba el contenido que yo había puesto en archivo,


package pruebas;

import java.io.*;
import java.lang.StringBuffer;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;

public class PruebaReader extends TestCase {

    protected Reader r;
    private File prueba;
    private StringBuffer buffer = new StringBuffer();
    
    protected void setUp() {
 try{
     this.prueba = new File("ejemplo.txt");
     this.r = new Reader("",prueba,buffer);
 }catch(Exception e){
     e.printStackTrace();
 }
 return;
    }
    
    public static Test suite() {
 return new TestSuite(PruebaReader.class);
    }

    public void testLeyendo() {
 System.out.println("Devolviendo Documento...");
 r.devolverDocumento();
 r.cerrarArchivo();
 super.assertEquals("Su hermano fue en su busca, a tierras muy lejanas.",buffer.toString());
 return;
    }

    public static void main(String[] args) {
 TestRunner.run(PruebaReader.suite());
 return;
    }
}

Prueba


Diseño de pruebas unitarias (clase)


(imagen obtenida de:https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjmNxRNBBszcJ_vwGtUBswRvnP6DIl7vxk7tL9nKxZi6KL93f7O1evFJ23s82qXj_9S7cH3kSjvMvcmKmEh4QkoKWU6b9LCGAvrzznSO0PO6JVgNN8QwmfdvleHX8IgAkXxz5RhEe5ZnRsL/s320/psicotecnico.jpg")



Buen día.
Esta semana voy dedicar esta publicación para hablar de las pruebas unitarias y de como voy a utilizar estas para verificar parte del contenido de mi código de proyecto.

Primero empezare definiendo pruebas unitarias.
Pues bien las pruebas unitarias son pruebas dirigidas a probar el correcto funcionamiento de las diferentes clases y métodos en nuestro sistema probandolos por separado.

Para hacer este tipo de pruebas en mi caso utilice JUnit que es un conjunto de clases que permite
realizar la ejecución de clases Java de manera controlada, para poder evaluar si el funcionamiento de cada uno de los métodos de la clase se comporta como se espera.

Utilizando JUnit
Para usar JUnit se crea una nueva clase java que es la que corre las pruebas y que siempre extiende a la clase TestCase del JUnit, Ahora para hacer las pruebas en esta clase crearemos métodos que empiezan con el nombre "test" así JUnit reconocerá los métodos que han de ser probados.

Métodos de comprobación:
assertEquals (valor_esperado, valor_real)
• Comprueba si “valor_esperado” y “valor_real” son iguales.
• “valor_real” es la salida que genera el método bajo prueba, “valor_esperado”
es lo que debería generar el método bajo prueba si funciona correctamente.
• Estos valores pueden ser de cualquier tipo nativo, de tipo String y Object (hay
distintos métodos para cada caso). Ojo, que si pasas arrays no los compara
elemento a elemento, sólo la referencia.

assertTrue (boolean condición)
• Comprueba que la condición es cierta.

assertFalse (boolean condición)
• Comprueba que la condición es falsa.

assertSame (Objeto esperado, Objeto obtenido)
• Comprueba que “obtenido” y “esperado” se refieren al mismo objeto.
Febrero 2004 JUNIT. Pruebas Unitarias 22
Pruebas con JUNIT: Explicación Formal (4)
Métodos de comprobación (2):

assertNotSame (Objeto esperado, Objeto obtenido)
• Comprueba que “obtenido” y “esperado” no se refieren al mismo objeto.

assertNull (Objeto objeto)
• Comprueba que el objeto indicado es nulo (referencia a null)

assertNotNull (Objeto objeto)
• Comprueba que el objeto pasado como parámetro no sea nulo (que referencia
a un objeto inicializado en memoria).

fail (String mensaje)
• Si en el código se alcanza y ejecuta esta sentencia, la prueba fallará.
• Se usa para marcar secciones de código que no deberían ejecutarse si todo
funcionara correctamente.
• Por ejemplo, justo después de una excepción para comprobar si ésta se lanza
correctamente.

Esta lista me sirvió de referencia para realizar las comprobaciones. Para utilizar estos, se llama al método o métodos a comprobar y por medio del valor regresado se comprueba si el método trabaja correctamente todo esto dentro del método test que corresponde  ala prueba.

TestReader
Para comprobar el correcto funcionamiento de la clase Reader cree un archivo de texto llamado "prueba.txt" y leí el contenido con esta clase con los métodos de la clase después compare el texto que ya sabía que tenía el archivo con el que me había regresado la clase.



TestWriter
Para comprobar la clase Writer simplemente cree dos objetos de el mismo archivo de prueba "prueba.txt" y sobre uno volví a rescribir el mismo texto que ya tenía al inicio lo compare con el objeto que no había sido editado y si los dos fuesen iguales la prueba era éxito los dos diferentes la prueba sería un fracaso.



Saludos.

referencias:
http://www.gsi.dit.upm.es/~legf/doc/lprg/Transparencias%20LPRG/Pruebas%20Unitarias.pdf
http://es.wikipedia.org/wiki/Prueba_unitaria
http://blog.continuum.cl/wp-content/uploads/2008/08/pruebas-unitarias.pdf

jueves, 7 de abril de 2011

Implementación de eventos, excepciones y errores propios (tall)

Buen día

En esta ocasión nos toco ver el tema de eventos, excepciones y errores así que para el taller de la materia identificamos los mismos en nuestro código para corregir o tratar errores y excepciones y mostrar o implementar eventos en o de nuestro código.

En primer lugar empezare con los ...

Eventos

Esta es la clase TextManager del proyecto que utilizo como escucha por cuestiones de comodidad ademas de ahorro de memoria. Esta clase tiene un método al cual se le notifica cuando ocurre un evento y sabe que hacer con este, todo esto hablando de la interfaz gráfica. hasta ahora solo tiene cuatro eventos pero cuando lleguemos al tema de interfaces gráficas probablemente tenga que agregar mas.

public class TextManager implements ActionListener { 
public void actionPerformed(ActionEvent e){
String cmd = e.getActionCommand();

if(cmd == "abrir")
this.abrir();

if(cmd ==  "nuevo")
System.out.println("Se ha picado nuevo");

if(cmd == "guardar")
this.guardar();

if(cmd == "guardarComo" )
this.guardarComo();
}
};

public class GUI extends javax.swing.JFrame{
public void barraPrincipal(TextManager listener){

JMenuItem abrir = new JMenuItem(jMenu[2]);
JMenuItem nuevo = new JMenuItem(jMenu[3]);
JMenuItem guardar = new JMenuItem(jMenu[4]);
JMenuItem guardarComo = new JMenuItem(jMenu[5]);
abrir.addActionListener(listener);
abrir.setActionCommand("abrir");
nuevo.addActionListener(listener);
nuevo.setActionCommand("nuevo");
guardar.addActionListener(listener);
guardar.setActionCommand("guardar");
guardarComo.addActionListener(listener);
guardarComo.setActionCommand("guardarComo");
}
};

Utilizo un solo escucha por que en mi caso el escucha utiliza el patrón Singleton puesto que si se crearan varios dividiría el programa en partes y seria menos eficiente.

Errores

Solo he tomado en cuenta dos errores y son la falla de alguna de estas clases del programa puesto que son las mas importantes y solo pueden ser implementadas una ves. así que en caso de que fallen falla todo el programa y no queda mas opción que terminarlo.

La clase TextManager que se encarga de administrar los archivos que se abren para editarlo, los que se crean y los que se guardan, ademas que sirve de escucha para los eventos generados por la interfaz gráfica.
try {
textActions = TextManager.obtenerInstancia(hojas);
}catch(Error e){
e.printStackTrace();
System.out.println("TextActions No se ha iniciado correctamente");
}

La clase GUI que contiene las hojas que sirven de campo de trabajo y cualquier opción controlable por el usuario, sin esta no tendría mucho sentido que siguiera ejecutándose el programa.
try {
GUI ventana = GUI.obtenerInstancia("MxText",hojas);
ventana.barraPrincipal(textActions);
}catch(Error e){
e.printStackTrace();
System.out.println("GUI No se ha iniciado correctamente");
}


Excepciones

Esta excepción se debería tirar al no poder abrir un archivo esta excepción notifica al TextManager que no fue posible abrir el documento para informarle al usuario.
public class Reader{
// Atributos
public String nameFile;
private File ar=null;
private FileReader fr=null;
private BufferedReader into =null;
private StringBuffer buffer =null;

//Constructor
public boolean abrirDocumento(){
try{
ar =fl;
fr = new FileReader(ar);
into = new BufferedReader(fr);
return true;
}catch(Exception e){
e.printStackTrace();
return false;
}
}
};


Esta excepción al igual que la anterior notifica ala clase TextManager por medio de un valor booleano que no se puedo guardar el archivo.
public class Writer{

// atributos
private String nameFile;
private File ar=null;
private FileWriter fw=null;
private StringBuffer buffer =null;
/**
* Constructor que ocupa la direccion del archivo con la informacion dada.
*/
public boolean guardarDocumento (){
try{
if(fl == null){
ar=new File(name);
}else{
ar =fl; }
fw = new FileWriter(ar);
return true;
}catch(Exception e){
e.printStackTrace();
return false;
}
}
];

En caso de que haya una excepción al devolver el documento entonces borra lo que haya agregado al buffer y devuelve un falso para que la clase TextManager sepa que hacer.
public class Reader{
public boolean devolverDocumento(){
 int c;
 try{
 while( (c = into.read()) != -1){
 buffer.append((char)c); 
 }
 return true;
 }catch(Exception e){
 e.printStackTrace();
 buffer.delete(0,buffer.capacity());
 return false;
 }
 
}

};

En caso de que al guardar haya un error en la clase Writer devuelve lanza la excepción y devuelve un valor falso.
public class Writer{
public boolean escribirDocumento(){
 try{
 fw.write(buffer.toString());
// es como solia decir la abuela argaslakslasdlaskjlaklskaslsj X_X
// abuela? abuela!!? :(
 return true;
 }catch(Exception e){
 e.printStackTrace();
 return false;
 }
}

};


Esas son algunos de mis eventos, excepciones y errores de mi proyecto saludos.

lunes, 4 de abril de 2011

Identificación de eventos, excepciones y errores propios (clase)

Buen día.
En esta semana me toca hablar acerca de los eventos, errores y las excepciones primero empezare definiendo cada concepto.

Errores
Es el resultado de un fallo o deficiencia durante el proceso de creación de programas de ordenador o computadora (software). Dicho fallo puede presentarse en cualquiera de las etapas del ciclo de vida del software aunque los más evidentes se dan en la etapa de desarrollo y programación. Los errores pueden suceder en cualquier etapa de la creación de software.

ejemplo:

[Imagen obtenida de "http://www.rpggamerpro.com/NWN_NO%20Disk_Windows_Error.jpg"]
Cuando se genera un error en el programa este no tiene otra opción que terminar su ejecución.

Eventos
Un evento es una acción del usuario ante la cual puede realizarse algún proceso.


Este es un ejemplo de un evento donde el botón abrir tiene asignado un escuchador, así que cuando el usuario presiona abrir el escuchador hace que se imprima el mensaje "se ha picado nuevo" en la pantalla.


Excepciones
Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe el flujo normal de las sentencias.

ejemplo


Esta excepción la produjo mi programa cuando intente abrir un archivo que estaba en una usb pero saque esta justo cuando lo estaba escogiendo, el programa me mostró un mensaje de error y el programa me creo una nueva hoja pero sin ningún archivo asignado así que me mostrara una hoja vacía lo cual puede traer problemas al usuario para evitar esto debo tratar esta excepción y pedir .


Para esta publicación voy a identificar algunos de los errores y excepciones que puedan ocurrir en mi software para así mas adelante saber como tratar con ellos. además de mostrar los eventos que tengo hasta ahora en mi software.

Eventos
  • Tengo un evento por cada botón que tengo en mi interfaz gráfica.
  • Estoy pensando en la idea de añadir un evento para cuando escriba algo



Errores
  • No poder iniciar la interfaz gráfica, problemas en la clase GUI.
  • No poder iniciar la clase TextManager que es la que controla los archivos que se abren.



Excepciones
  • Tratar de abrir un archivo que que ha sido movido mientras se selecciona y mostrar en la pantalla que se ha abierto.
  • Tratar de guardar un archivo que eh sido modificado u eliminado por otro programa mientras se trabajaba con el.
  • Recuperar solo parte del archivo por la clase Reader o escribir solo parte por la clase Writer.
  • Al abrir, leer, escribir y cerrar en un archivo cualquier excepción.




jueves, 31 de marzo de 2011

Patrones de diseño(taller)

Buen día.

Esta semana estamos viendo en clase la utilidad de los patrones de diseño así que para el taller voy a utilizar dos patrones para mejorar mi código y para resolver un problema de forma eficiente.

Singleton

La clase "TextManager" y la clase "GUI" de mi proyecto solo necesitan una instancia pero en caso de que se crearan mas instancias seria molesto o correria riesgo el programa de fallas asi que para asegurar que eso no pase al continuar avanzando en el proyecto pense que este seria el patrón de diseño que me ayudaria.

El patrón de diseño singleton (instancia única) está diseñado para restringir la creación de objetos pertenecientes a una clase o el valor de un tipo a un único objeto.

Y aquí las partes de cada clase donde implemento Singleton
singleton en la clase GUI :)
package mxText;
import javax.swing.*;
import java.awt.*;
public class GUI extends javax.swing.JFrame{

private int numerodeBotones;
private static GUI instancia = null;
private Sheet texto;
JPanel p1, p2;
JMenuBar barraMenu;
String[] jMenu={"Archivo","Editar","Abrir","Nuevo","Guardar","Guardar Como"};

private GUI(String titulo, JTabbedPane tabs){
super(titulo);
super.setTitle(titulo);
super.setLocation(0,0);
super.setSize(500,500);
super.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
super.setLayout(new BorderLayout());
p1 = new JPanel();
p2 = new JPanel();
super.add(p1,BorderLayout.CENTER);
p1.setLayout(new BorderLayout());
this.texto = texto;
//JScrollPane scrollb = new JScrollPane(this.texto);
//JTabbedPane tabs = tabs;
p1.setPreferredSize(new Dimension(20,5));
barraMenu = new JMenuBar();
super.add(p2,BorderLayout.NORTH);
super.setJMenuBar(barraMenu);
//tabs.addTab("archivo 1",scrollb);
p1.add(tabs, BorderLayout.CENTER);
super.setVisible(true);
}


private synchronized static void crearInstancia(String titulo, JTabbedPane tabs){
if(instancia == null){
instancia = new GUI( titulo, tabs);
}
}

public static GUI obtenerInstancia(String titulo, JTabbedPane tabs){
if(instancia == null)
crearInstancia(titulo, tabs);
return instancia;
}

public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}

};


Singleton en la clase TextManager:
package mxText;
import javax.swing.JFileChooser;
import javax.swing.*;
import javax.swing.text.*;
import java.io.File;
import java.lang.StringBuffer;
import java.awt.event.*;
import java.util.*;
/**
* Sirve para trabajar con el texto de un archivo y prepararlo para imprimirlo en la pantalla o en una hoja.
* @author Max Hernandez
*/
public class TextManager implements ActionListener {
private static TextManager instancia = null;
String nombreDeArchivo=null;
Reader lector =null;
JTabbedPane hojas =null;
Writer escritor =null;
Compuesto tabs;
StringBuffer buffer = new StringBuffer();
File fichero;
JFileChooser fileChooser= new JFileChooser();

private TextManager(JTabbedPane hojas){}

private synchronized static void crearInstancia(){
if(instancia == null){
instancia = new TextManager();
}
}

public static TextManager obtenerInstancia(JTabbedPane hojas){
this.hojas=hojas;
tabs = new Compuesto(hojas);
if(instancia == null)
crearInstancia();
return instancia;
}

public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}

};


Composite

Para abrir gran cantidad de archivos y administrarlos por el usuario ya había planeado usar JTabbedPane pero no sabia exactamente como estructurarlos, sabia que necesitaría una lista y un buen algoritmo.

El patrón "Composite" sirve para construir objetos complejos a partir de otros más simples y similares entre sí. entonces de cierta forma lo uso para agregar componentes al JTabbedPane utilizandolo como una lista. Gracias a esto puedo definir componentes con las caracteristicas que quiera y asi cumplir varias funciones como en mi ejemplo el unico componente que uso al mismo tiempo guarda informacion del archivo y objetos para que funcione correctamente.

Este es el pedazo de código de la clase "TextManager" donde se implementa este patron de diseño despues de esto para abrir archivos solo creo un obeto "Tab" con los parametros necesarios, un compuesto y voy añadiendo archivos.
abstract class Componente extends JScrollPane
{
public File archivo;
public Sheet hoja ;
public String nombreArchivo;
public Componente(File ar, String nF, Sheet hoja){
super(hoja);
this.archivo = ar;
this.hoja = hoja;
this.nombreArchivo = nF;
}
public Componente(){}
abstract public void Agregar(Componente c);
};

class Compuesto extends Componente
{

private ArrayList hijo = new ArrayList();
private JTabbedPane tabs;
public Compuesto (JTabbedPane tabs){
this.tabs=tabs;
}
@Override
public void Agregar(Componente comp)
{
hijo.add(comp);
tabs.addTab(comp.nombreArchivo,comp);
}
};

class Tab extends Componente
{

public Tab (File fl, String nF, Sheet hoja)
{
super(fl,nF, hoja);
}
public void Agregar(Componente c)
{
System.out.println("no se puede agregar la tab");
}
public void Remover(Componente c)
}
System.out.println("no es posible completar la petición");
public void Mostrar(int depth)
{
System.out.println('-' + "" + nombreArchivo);
}
};



domingo, 27 de marzo de 2011

Patrones de diseño(Clase)

Buen día.
Como en la programación orientada a objetos la reutilización de herramientas es muy habitual esta semana nos toco tocar el tema de los patrones de diseño.
Los patrones de diseño los cuales son soluciones estandar para problemas comunes en la programacion. Ademas que agiliza la planeación, estructuración y codificación de un proyecto.
Un patrón de diseño es una solución a un problema de diseño.

Para la publicación de esta semana voy a analizar los diferentes tipos de patrones de diseño los cuales pueden ser de utilidad en mi proyecto.


Singleton

El patrón de diseño singleton (instancia única) está diseñado para restringir la creación de objetos pertenecientes a una clase o el valor de un tipo a un único objeto.

Utilizare este patron el mis clases "TextManager" y "GUI" estas clases se encargan de administrar los archivos que son abiertos y dibujar una ventana que permite configurar diferentes opciones para el programa respectivamente. Creo que esto me sera util para evitar errores al iniciar el programa asi se evita que se abra una ventana extra o que los archivos que gestiona "TextManager" este divididos en dos o mas instancias de este.



Composite

El patrón Composite sirve para construir objetos complejos a partir de otros más simples y similares entre sí, gracias a la composición recursiva y a una estructura en forma de árbol.

Este patrón me parece util para poder abrir n cantidad de archivos con el programa y organizarlos en "tabs" con esto creo un componente que serias los "tabs" con las hojas y despues solo los agrego a un compuesto que sera una lista con los tabs que tengo, despues cada que el usuario quiera una nueva hoja el programa solo agrega un componente a la lista.



jueves, 24 de marzo de 2011

Demostraciones avance parcial (tall)

buen día.
Esta publicación esta dedicado a mostrar el estado actual de mi proyecto así que mostrare su funcionamiento y abajo mi código.



package mxText;
import java.lang.StringBuffer;
//import mxEdit.*;
/**
* Gestiona el editor de texto para que funcione correctamente y junta diferentes partes.
* @author Max Hernandez
*
*/
public class MxText {
/**
*/
String nombreArchivo;
Sheet areaTexto = new Sheet();
TextManager textActions;
//TextManager manager = null;
//GUI Grafic = null;
public MxText(){
textActions = new TextManager(areaTexto);
GUI ventana = new GUI("Soy una ventana",areaTexto);
ventana.barraPrincipal(textActions);
}

//void Main(){}
/**
* Crea un archivo con las opciones de usuario.
*/
public void opciones(){}


public static void main(String[] args){
MxText CorazonNegro = new MxText();
}

};


package mxText;
import javax.swing.*;
import java.awt.*;
//import mxEdit.Sheet;
/**
*Clase que sirve de interfaz grafica para un programa podria utilizarse como base
*para cualquier programa, esta se encarga de dibujar una ventana en la pantalla y
*agregar diferentes elementos y controlarlos.
* @author Max Hernandez
*/
public class GUI extends javax.swing.JFrame{

private int numerodeBotones;
private Sheet texto;
JPanel p1, p2;
JMenuBar barraMenu;
String[] jMenu={"Archivo","Editar","Abrir","Nuevo","Guardar","Guardar Como"};

public GUI(String titulo, Sheet texto){
super(titulo);
super.setTitle(titulo);
super.setLocation(0,0);
super.setSize(500,500);
super.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
super.setLayout(new BorderLayout());
p1 = new JPanel();
p2 = new JPanel();
super.add(p1,BorderLayout.CENTER);
p1.setLayout(new BorderLayout());
this.texto = texto;
JScrollPane scrollb = new JScrollPane(this.texto);
JTabbedPane tabs = new JTabbedPane();
p1.setPreferredSize(new Dimension(20,5));
barraMenu = new JMenuBar();
super.add(p2,BorderLayout.NORTH);
super.setJMenuBar(barraMenu);
tabs.addTab("archivo 1",scrollb);
p1.add(tabs, BorderLayout.CENTER);
super.setVisible(true);
}
/**
* Es la clase que prepara todos los componentes para e imprime en la pantalla.
*/
public void barraPrincipal(TextManager listener){
JMenu archivo = new JMenu(jMenu[0]);
JMenu editar = new JMenu(jMenu[1]);
barraMenu.add(archivo);
barraMenu.add(editar);
JMenuItem abrir = new JMenuItem(jMenu[2]);
JMenuItem nuevo = new JMenuItem(jMenu[3]);
JMenuItem guardar = new JMenuItem(jMenu[4]);
JMenuItem guardarComo = new JMenuItem(jMenu[5]);
abrir.addActionListener(listener);
abrir.setActionCommand("abrir");
nuevo.addActionListener(listener);
nuevo.setActionCommand("nuevo");
guardar.addActionListener(listener);
guardar.setActionCommand("guardar");
guardarComo.addActionListener(listener);
guardarComo.setActionCommand("guardarComo");
archivo.add(nuevo);
archivo.add(abrir);
archivo.add(new JSeparator());
archivo.add(guardar);
archivo.add(guardarComo);
}

public void dibujar(){

}
/**
* Este metodo se encarga de cambiar la posición de los elementos en la pantalla.
* @param elemt numero que identifica el elemento.
* @param cord cordenada de a donde se desea mover el elemento
* @return cordenada Regresa la cordenada en la pantalla del elemento movido o un -1 si no se puede mover
*/
public int moverElemento(){return 0;}
/**
* Alamacena y gestiona la posicion en la pantalla de los elementos cuales deses sean añadidos.
* @return cordenada
*/
public void gestorElemento(){}
/**
* Recibe elementos y les da un lugar en la pantalla para despues ser gestionado.
*/
public void anadirElemento(){}

};


package mxText;
import java.nio.charset.Charset;
import java.io.*;
import java.lang.StringBuffer;
/**
* Clase que verifica la códificacion de un arcvhio y despues regresa el contenido de este.
* @author Max Hernandez
*/
public class Reader{
// Atributos
public String nameFile;
private File ar=null;
private FileReader fr=null;
private BufferedReader into =null;
private StringBuffer buffer =null;

//Constructor
public Reader(String name,File fl, StringBuffer buffer){
this.nameFile = name;
this.buffer= buffer;
try{
ar =fl;
fr = new FileReader(ar);
into = new BufferedReader(fr);
}catch(Exception e){
e.printStackTrace();
}
}

/**
* prepara el texto para ser pedido por la clase Administradora de texto.
*/
void lector(){}
/**
* Revisa la codificación de caracteres del archivo.
*/
public void decodificador(){}
/**
* Devuelve el contenido de el documento en un estado con el cual es facil para un programa trabajar.
*/

public void devolverDocumento(){
int c;
try{
while( (c = into.read()) != -1){
buffer.append((char)c);
}
buffer.deleteCharAt(buffer.length()-1);
}catch(Exception e){
e.printStackTrace();
}

}

public void cerrarArchivo(){
try{
fr.close();
}catch(Exception e){
e.printStackTrace();
}
}


/*public static void main(String[] args){

StringBuffer bufferFeliz = new StringBuffer();
Reader leer = new Reader(args[0], bufferFeliz);
leer.devolverDocumento();
leer.cerrarArchivo();

System.out.print(bufferFeliz.toString());
}*/

};


package mxText;

/**
* Esta clase es una extencion de una herramienta que sirve de interfaz
* entre el usuario y el programa. Es una area donde se ingresa y se edita
* el texto de archivos.
*@author Max Hernandez
*/
class Sheet extends javax.swing.JTextPane { // Una pare de la interfaz grafica y sabe estructurar el texto en la pantalla

public Sheet(){
super();
}
/**
* Método que se encarga de imprimir el texto en la pantalla.
*/
void dibujar(){} // lo que sea que le manden
/**
* Verifica el área de texto para ver las modificaciónes hechas por el usuario al texto.
*/

}


package mxText;
import javax.swing.JFileChooser;
import java.io.File;
import java.lang.StringBuffer;
import java.awt.event.*;
/**
* Sirve para trabajar con el texto de un archivo y prepararlo para imprimirlo en la pantalla o en una hoja.
* @author Max Hernandez
*/
public class TextManager implements ActionListener {

String nombreDeArchivo=null;
Reader lector =null;
Sheet hoja =null;
Writer escritor =null;
StringBuffer buffer = new StringBuffer();
File fichero;
JFileChooser fileChooser= new JFileChooser();
/**
* Buscar elementos en un texto
*/

public void actionPerformed(ActionEvent e){
String cmd = e.getActionCommand();

if(cmd == "abrir")
this.abrir();

if(cmd == "nuevo")
System.out.println("Se ha picado nuevo");

if(cmd == "guardar")
this.guardar();

if(cmd == "guardarComo" )
this.guardarComo();
}


public TextManager(Sheet hoja){
this.hoja=hoja;
}
public void buscar(){}
public void abrir(){
fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
int seleccion = fileChooser.showOpenDialog(hoja);
if (seleccion == JFileChooser.APPROVE_OPTION){
buffer.delete(0,buffer.capacity());
fichero = fileChooser.getSelectedFile();
lector = new Reader(" ",fichero,buffer);
lector.devolverDocumento();
lector.cerrarArchivo();
hoja.setText(buffer.toString());
}
}
public void guardar(){
buffer.delete(0,buffer.capacity());
buffer.append(hoja.getText());
escritor = new Writer("",fichero,buffer);
escritor.escribirDocumento();
escritor.cerrarArchivo();
}
public void guardarComo(){
fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
int seleccion = fileChooser.showOpenDialog(hoja);
if (seleccion == JFileChooser.APPROVE_OPTION){
fichero = fileChooser.getSelectedFile();
}
}
/**
* Organiza el texto para mas sensilla modificación.
*/
public void acomodarTexto(){}

}


package mxText;
import java.nio.charset.Charset;
import java.io.*;
import java.lang.StringBuffer;
/**
* La funcionalidad de esta clase va orientada a la impresion de datos
* en un archivo de texto, revisa la códificacion de caracteres y tiene los metodos
* necesarios para obtener.
* @author Max Hernandez
*/
public class Writer{

// atributos
private String nameFile;
private File ar=null;
private FileWriter fw=null;
private StringBuffer buffer =null;
/**
* Constructor que ocupa la direccion del archivo con la informacion dada.
*/
public Writer (String name,File fl, StringBuffer buffer){
this.nameFile = name;
this.buffer= buffer;
try{
if(fl == null){
ar=new File(name);
}else{
ar =fl; }
fw = new FileWriter(ar);
}catch(Exception e){
e.printStackTrace();
}
}
/**
* Guarda en un archivo la informacion que se le es mandada caracter por caracter con su codificacion
* que le es mandada.
*/
void escribirDocumento(){
try{
fw.write(buffer.toString());
// es como solia decir la vieja abuela argaslakslasdlaskjlaklskaslsj X_X
// abuela? abuela!!? :(
}catch(Exception e){
e.printStackTrace();
}
}
void cerrarArchivo(){
try{
fw.close();
}catch(Exception e){
e.printStackTrace();
}
}

/*public static void main(String[] args){
StringBuffer bufferFeliz = new StringBuffer();
bufferFeliz.append("Su hermano fue en su busca, a tierras muy lejanas. En medio de las tropas, jugándose hasta el alma. Aquel corazón negro, de oscuros sentimientos, quedo en el pasado hoy es un gran guerrero. La tierra que lo vio nacer, celebra su regreso.");
Writer escribir = new Writer(args[0], bufferFeliz);
escribir.escribirDocumento();
escribir.cerrarArchivo();
}*/

};


Hasta ahora mi editor de texto es capaz de desplegar una ventana con un JFrame, y adentro de esta un area de trabajo esto logrado con la clase JTextPane escogì esta clase puesto que es la mas potente que encontre en las clases estandar de java. para la barra superior use un JMenuBar que lo unico que hace es mostrar la barra, despues le añado elementos con el JMenu y les asigno un listener que se encuentra en la clase TextManager.

Con la opciòn abrir tiene la capacidad de mostrar esta ventana que la agregue facilmente con un JFileChoose y esta regresa un File el cual mando a mi clase Reader este optiene todo el texto y lo guarda en un StringBuffer para regresarlo a TextManager para que este lo mande a la clase Sheet y se imprima en la pantalla.


Para guardarlo solo se da clik a la opcion guardar y con eso el editor ya tiene la capacidad de editar archivos sin estructura.
Hasta ahora solo puedo ver un archivo ala ves pero mis proximas metas son utilizar una lista enlazada para crear "n" numero de tabs para "n" numero de archivos para "n" numero de Sheets .
Mi otra meta es lograr que reconozca estructura o palabras en el texto y las resalte cambiandoles el color.

Saludos.

miércoles, 16 de marzo de 2011

Diagramas de clases y secuencia UML (taller)

Buen día.
Esta semana en el taller nos toca ver como utilizar una software para modelado de diagramas para convertir código a diagramas o viceversa.
Para hacer esto utilice la herramienta Umbrello y voy a mostrar paso a paso como utilice esta herramienta.

Esto me fue de utilidad ya que con esto me ayudo a darme cuenta de problemas con el diseño de mi programa.

En primer lugar descargue e instale esta herramienta. en mi caso la descargue e instale desde Ubuntu Software Center pero también se encuentra en su pagina oficial: http://uml.sourceforge.net/download.php
Después lo ejecute y me pidio una especie de registro nada complicado, luego me apareció esta ventana y ya estaba listo para utilizarse.


Gracias a esta herramienta importar código a un diagrama UML fue bastante sencillo, en la barra de opciones que esta arriba escogí la opción code>import proyect como se muestra en la imagen.



Con lo anterior se me desplegó la siguiente ventana donde especifiqué la carpeta donde se encuentra el código y el lenguaje en el que fue creado.
Con esto umbrello me organizo automaticamente las clases de mi proyecto y me las mostro como un arbol en la parte izquierda, desde ahi se pueden editar los nombres, metodos y aributos de cada clase.

Ahora para crear el diagrama de clases simplemente arrastre las clases al área de trabajo y se dibujo automaticamente. cabe destacar que si en tu código un método de la la clase es privado al importar el diagrama y arrastrar la clase al área de trabajo no se mostrara ese método.

Umbrello automaticamente me crea el diagrama junto con las flechas que especifican la interacción entre los programas.
Para pasar el diagrama a código primero tenemos que especificar el lenguaje en el que trabajamos para esto vamos a code>Active Language y seleccionamos el lenguaje en el que trabajamos que en mi caso es java.



Ahora para pasar el diagrama a código seleccionamos la opción code>Generate All Code y automaticamente nos crea el paquete de código en tu carpeta de usuario de ubuntu ahí nos pedirá la carpeta uml-generated-code pero en caso de no tenerla la crea el programa.
Esta es la carpeta con el proyecto que me creo Umbrello.



Y esta es el código de la clase MxText que me genero umbrello

package mxEdit;


/**
* Class MxText
*/
public class MxText {

//
// Fields
//
/**

*
* */

public String[] usuario;

//
// Constructors
//
public MxText () { };

//
// Methods
//


//
// Accessor methods
//

/**
* Set the value of usuario
*
*
* @param newVar the new value of usuario
*/
public void setUsuario ( String[] newVar ) {
usuario = newVar;
}

/**
* Get the value of usuario
*
*
* @return the value of usuario
*/
public String[] getUsuario ( ) {
return usuario;
}

//
// Other methods
//

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


/**
* @param args
*/
public static void main( String[] args )
{
}


}
como puede verse en el código el programa me construye las clases, métodos, da nombre a algunas variables y me genera documentación.

Saludos.

Diagramas de clases y secuencia UML (clase)

Buen día.

Esta semana el tema a tratar en clase son los diagramas de lenguaje unificado de modelado o UML(Unified Modeling language)es el lenguaje de modelado de sistemas de software más conocido y utilizado en la actualidad.

Este lenguaje de modelado se compone de trece diagramas para esquematizar nuestro software los cuales son los siguientes:
Los Diagramas de Estructura enfatizan en los elementos que deben existir en el sistema modelado:
  • Diagrama de clases
  • Diagrama de componentes
  • Diagrama de objetos
  • Diagrama de estructura compuesta (UML 2.0)
  • Diagrama de despliegue
  • Diagrama de paquetes

Los Diagramas de Comportamiento enfatizan en lo que debe suceder en el sistema modelado:
  • Diagrama de actividades
  • Diagrama de casos de uso
  • Diagrama de estados

Los Diagramas de Interacción son un subtipo de diagramas de comportamiento, que enfatiza sobre el flujo de control y de datos entre los elementos del sistema modelado:
  • Diagrama de secuencia
  • Diagrama de comunicación, que es una versión simplificada del Diagrama de colaboración (UML 1.x)
  • Diagrama de tiempos (UML 2.0)
  • Diagrama global de interacciones o Diagrama de vista de interacción (UML 2.0)

Estos diagramas nos permiten tener una representación visual dinámica de nuestro software tanto de la estructura de este como su comportamiento o la secuencia de ejecución de el mismo. Con esto podemos darnos una mejor idea de el funcionamiento de nuestro programa al planearlo lo cual nos ayuda a evitar algunos errores en nuestro trabajo.

La primera version de UML salio a la luz en 1997 después de que James Rumbaugh,Ivar Jacobson se unieran a la compañía de Grady Booch así juntaron sus ideas y crearon este lenguaje de modelado después a estas personas se les conoció como "los tres amigos".
Para esta publicación me centrare en dos diagramas en especial que son el diagrama de clases y el de secuencia. Para fabricarlos utilice umbrello una herramienta gratuita para ubuntu y windows. Experimente algunos bugs mientras lo usaba pero es cómoda y tiene lo necesario para crear diagramas.
esta es la página oficial:
http://uml.sourceforge.net/

DIAGRAMA DE CLASES



DIAGRAMA DE SECUENCIA



fuentes:
http://es.wikipedia.org/wiki/Lenguaje_Unificado_de_Modelado
http://www.programacion.com/articulo/introduccion_a_uml_181
http://www.ingenierosoftware.com/analisisydiseno/uml.php

saludos.

jueves, 24 de febrero de 2011

Especificación Técnica(tall)

Buen día.

Esta semana nos ah tocado ver especificaciones técnicas para lo cual primero me pregunte ¿Que es una especificacion tecnica? Lo que hize para responder esta pregunta es lo que toda persona con internet normalmente haria lo busque en google y esto fue lo que encontre.

segun wikipedia:
Las especificaciones técnicas son los documentos en los cuales se definen las normas, exigencias y procedimientos a ser empleados y aplicados en todos los trabajos de construcción de obras, elaboración de estudios, fabricación de equipos ..., etc.
http://es.wikipedia.org/wiki/Especificaciones_t%C3%A9cnicas
pero aun no me quedaba claro puesto que esta definicion no se refiere especificamente a un software.

segun http://spanish.joelonsoftware.com
Una especificación técnica describe la implementación interna del programa. Habla de estructuras de datos, modelos de bases de datos relacionales, elección de lenguajes y herramientas de programación, algoritmos, etc.
http://spanish.joelonsoftware.com/PainlessSpecs/2.html
Esta definicion me ayudo a poner pies en tierra sobre como debía hacer la especificación técnica.

Para complementar esta informacion nada mejor que ejemplos y esto fue lo que encontre al respecto:
Ahora esta es la especificacion de mi programa.


Especificacion Tecnica

jueves, 17 de febrero de 2011

Documentación y herramientas de desarrollo(taller)

Muy buen día.

Esta semana nos toco hablar de la documentación de los códigos así que para la clase de taller fabrique una documentación de mi avance del proyecto.

Para esto utilice "javadoc" que es una herramienta que viene por defecto en el kit de desarrollo de java este toma todos los comentarios de nuestro código y lo pasa a un HTML donde queda listo para presentarlo.

como puede verse se crea la documentación tal cual se compila un archivo solo que se utiliza el programa "javadoc".

Sin mas aquí pongo el enlace a mi documentación:

http://www.maxkalavera.iblogger.org/


Aquí el estado actual de el código.

Clase

package textedit;
/**
*Clase que sirve de interfaz grafica para un programa podria utilizarse como base
*para cualquier programa, esta se encarga de dibujar una ventana en la pantalla y
*agregar diferentes elementos y controlarlos.
* @author Max Hernandez
*/
public class GUI extends javax.swing.JFrame{

private int numerodeBotones;
/**
* Es la clase que prepara todos los componentes para e imprime en la pantalla.
*/
public void dibujar(){}
/**
* Este metodo se encarga de cambiar la posición de los elementos en la pantalla.
* @param elemt numero que identifica el elemento.
* @param cord cordenada de a donde se desea mover el elemento
* @return cordenada Regresa la cordenada en la pantalla del elemento movido o un -1 si no se puede mover
*/
public int moverElemento(){}
/**
* Alamacena y gestiona la posicion en la pantalla de los elementos cuales deses sean añadidos.
* @return cordenada
*/
public void gestorElemento(){}
/**
* Recibe elementos y les da un lugar en la pantalla para despues ser gestionado.
*/
public void anadirElemento(){}

}



Clase

package textedit;
import java.nio.charset.Charset;
import java.io.*;
/**
* Clase que verifica la códificacion de un arcvhio y despues regresa el contenido de este.
* @author Max Hernandez
*/
public class Reader extends java.io.InputStreamReader {
// Atributos
private String[] nameFile;
private String[] extension;

//Constructor
public Reader(String[] name, String[] ext, File fl){
super(fl);
this.nameFile = name;
this.extension = ext;
}

/**
* prepara el texto para ser pedido por la clase Administradora de texto.
*/
void lector(){}
/**
* Revisa la codificación de caracteres del archivo.
*/
private void decodificador(){}
/**
* Devuelve el contenido de el documento en un estado con el cual es facil para un programa trabajar.
*/
private void devolverDocumento(){}

}



Clase

package textedit;
import java.io.*;
/**
* La funcionalidad de esta clase va orientada a la impresion de datos
* en un archivo de texto, revisa la códificacion de caracteres y tiene los metodos
* necesarios para obtener.
* @author Max Hernandez
*/
public class Writer extends java.io.OutputStreamWriter {

// atributos
private String[] nombreDelArchivo;
private String[] extension;
private int numeroDeLineas;
/**
* Constructor que ocupa la direccion del archivo con la informacion dada.
*/
public Writer (String []nombreDelArchivo, File fl){
super(fl);
}
/**
* Guarda en un archivo la informacion que se le es mandada caracter por caracter con su codificacion
* que le es mandada.
*/
private void guardar(String[] nombreDelarchivo, String[] extencion, String[] datos){}
}



Clase

package textedit;
/**
* Gestiona el editor de texto para que funcione correctamente y junta diferentes partes.
* @author Max Hernandez
*
*/
public class Main{
/**
*/
String[] usuario;

void Main(){};
/**
* Crea un archivo con las opciones de usuario.
*/
public void opciones(){}
public static void main(String[] args ){
System.out.println("Working...");

}
}



Clase

package textedit;

/**
* Esta clase es una extencion de una herramienta que sirve de interfaz
* entre el usuario y el programa. Es una area donde se ingresa y se edita
* el texto de archivos.
*@author Max Hernandez
*/
public class Sheet extends javax.swing.JTextArea { // Una pare de la interfaz grafica y sabe estructurar el texto en la pantalla

private int numeroLineas(){}

/**
* Método que se encarga de imprimir el texto en la pantalla.
*/
void dibujar(){} // lo que sea que le manden
/**
* Verifica el área de texto para ver las modificaciónes hechas por el usuario al texto.
*/

}



Clase

package textedit;
/**
* Sirve para trabajar con el texto de un archivo y prepararlo para imprimirlo en la pantalla o en una hoja.
* @author Max Hernandez
*/
public class TextManager{

String[] nombreDeArchivos;
String[] extension;

/**
* Buscar elementos en un texto
*/
public void buscar();
/**
* Organiza el texto para mas sensilla modificación.
*/
public void acomodarTexto();

}

miércoles, 16 de febrero de 2011

Documentación y herramientas de desarrollo(clase)

En esta semana tratamos en clase de las herramientas para documentar nuestro código así que explicare un poco acerca de su utilidad y como construirla.

En primer lugar ¿que es la documentación?
La documentación es una guía detallada acerca de como funciona funciona nuestro código, estructura, y como utilizarlo.

¿Para que nos sirve esto?
  • Permite la reutilización del código sin tener que entenderlo a la perfección.
  • Al intentar darle mantenimiento a tu código la documentación vuelve mas sencilla esta tarea.
  • Compartir tu código para que cualquiera pueda sacarle provecho.
  • Si se trabaja con un grupo de personas estas no tendrán que tocar tu código para saber como funciona.
¿ Como hacemos una documentación?
Para lograr esto hay muchas herramientas que hacen mas sencilla la tarea por ejemplo : Doxygen, AdaDoc(para ada), Cxref (documentacion para C), Latex, pascdoc, etc.

Aquí por causalidad me tope con esta pequeña lista de herramientas para documentar:

Si Estas trabajando en java como yo, java ya nos proporciona una herramienta para crear documentacion en formato html esta herramienta es "JavaDoc".

Para crear una documentacion por medio de javadoc se escribe lo que se desea documentar dentro de un comentario que inicia con "/**" y termina con "*/" dentro de estas se puede poner HTML o etiquetas que normalmente inician con un "@" (por lo general son elementos básicos de un código), por ejemplo:



{ /** Esto es un ejemplo de como hacer una documentacion.
* @author Max Hernandez :D
* @version la version de este programa.
*/
public class ejemplo{
/**
Este es el método mas importante del codigo :p
@param args Este es el parametro de mi código pero seguro que el tuyo tendra mas

*/
public static void main(String[] args){
System.println("Soy un ejemplo");
}
}

Sugerencias.
  • Los comentarios deben ser lo mas concisos y lo mas precisos posibles.
  • Marcas las palabras clave.
  • Lo ideal es que tengo la documentación tenga la información suficiente para saber como funciona o para que sirve cada: clase, cada método de cada clase, cada parámetro, cada bloque de código que pueda causar duda.
Lo que hará javadoc es tomar todos los comentarios de tu programa acomodarlos en un HTML, se acomodaran dependiendo de la estructura de tu programa y mostrar sus características como el paquete o las relaciones de herencia.

Aquí una lista de tags de javadoc de la pagina oficial de java:



miércoles, 9 de febrero de 2011

Herencia y polimorfismo (taller).

Muy buen día.

Esta semana nos entramos al tema de herencia y polimorfismo, una herramienta que sirve para reutilizar código y reutilizar código.
Para mi software no pienso heredar un objeto de los que definí para mi software hace unas pocas semanas debido a que no me parecen lo suficiente abstractos así que solo aprovechare las clase de java ya existentes de java, las heredare a las mías y las orientare a mi conveniencia

La clase Lectora extendí la clase InpytStreamReader que métodos tales como regresar codificación de caracteres del archivo que se busca leer, leer carácter, leer un rango de caracteres que es lo que básicamente necesita esta clase.

package textedit;
import java.nio.charset.Charset;
public class Reader extends java.io.InputStreamReader {
// Atributos
private String[] nameFile;
private String[] extension;

//Constructor
public Reader(String name, String ext){
super(InputStream in, Charset cs);
this.nameFile = name;
this.extension = ext;
}

// Metodos
void lector(){} // prepara el texto para ser pedido por la clase Administradora de texto
private void decodificador(){} // esto podria dejarselo a la clase Charset
private void devolverLinea(){}
private void devolverDocumento(){}

}


Para la clase escritora escogí extender OutputStreamWriter que tiene métodos muy parecidos a InputStreamReader pero en escritura.


package textedit;

public class Writer extends OutputStreamWriter{

// atributos
private String[] nameFile;
private String[] extension;
private int nlines;

//Contructor
public Writer(String[] name, String[] ext){
super();
this.nameFile = name;
this.extension = ext;
}

// Metodos
private void codificar(String extension){}// Charset espero que me salve aquí
private void guardar(string[] nombreDelarchivo, String[] extencion, String[] datos){} // guarda usando las clases de OutputStreamWriter


}


Para la hoja extendí el JTextArea que se encarga de dibujar texto en la pantalla, tiene muchos metodos muy útiles.

package textedit;

public class Sheet extends javax.swing.JTextArea { // Una pare de la interfaz grafica y sabe estructurar el texto en la pantalla
// atributos
private int numeroLineas(){}

// Metodos
void intermedioEscucha(){} // comunicacion con intermedia
void dibujar(); // lo que sea que le manden

}


En la Interfaz gráfica me parece que lo primero que necesitas es el espacio donde mostrar tu programa así que mi GUI sera una hija de la clase JFrame que lo que hace es crear una ventana para trabajar.

package textedit;

public class GUI extends javax.swing.JFrame{
// atributos
private int numerodebotones;
// Metodos
private void dibujar(){}

}