Demostración final

Aqui encontraras la documentacion para usar el programa.

https://rapidshare.com/files/775793383/Documentacion_de_usuario.pdf

y los codigo fuente del progama

https://rapidshare.com/files/860542826/proyecto.zip

Sistemas distribuidos

Objetivo: Planear la distribución de su software (en el sentido de sistemas distribuidos).

Contenido esperado de la entrada: Redacción donde indiquen arquitecturas, tecnologías y/o middleware que pueden utilizar para hacer que su software sea distribuido. Es válido utilizar imágenes para la explicación.

Pruebas unitarias

Objetivo: Correr casos de prueba en su software.

Contenido esperado de la entrada: Reporte de resultados de pruebas (pueden poner el resultado que les arrojó la herramienta de pruebas).

Interfaz gráfica

Objetivo: Codificar la interfaz gráfica de su software.

Contenido esperado de la entrada: Capturas de pantalla con interfaz gráfica (real) de su software.

Que tal tratare de explicar que es lo que hace cada pantalla y como funciona.

Ventana Principal - Aqui nos mustra 2 botones el cual nos permite hacer, como su nombre lo indica, las acciones correspondientes. Agregar Archivo, abre un nueva ventana para seleccionar el archivo y Ver Archivos, te lleba a vizualizador que es donde nosotros podemos ver lo que esta contenido.

Agregar Archivo - En esta seccion tu proporcionaras los datos de tu archivo y decidiras si lo quieres guardar o concelar. Al dar click en el boton guardar con los campos vacios, no agregara el archivo y te mostrara un mensaje de Vuelve a intentar. El JFielText es para indicarle el nombre que nosotros le queremos dar al archivo, no necesariamente tiene que ser el mismo, mas bien un nombre para recordarlo.



Al hacer click en el boton Examinar, aparecera una pantalla similar a la de abajo, en donde tu podras elegir tu archivo, entre cualquier directorio, esto lo hise gracias a una libreria llamada JFileChooser



Visualizador, contiene los botones, siguientes lo cual su accion es ir hacia adelante o atras entre el total de archivos, elimiar el archivo en el que te encuentras, eliminar el archivo.

Boton Suguiente - avanza entre el total de archivos



Eliminar un arhivo permite borrar el archivo seleccionado de la base de datos, el problema con este boton es que al dar click si lo elimina, pero el rastro queda en visualizador, entonces cuando "vualves a pasar por donde estaba tu archivo eliminado" te muestra un error (lo cual no deberia hacer) y despues no te permita hacer otra cosa.

y el boton ver, me falto hacerlo funcionar bien, el objetivo era que al hacer tu click en el, te abriera el pdf como si lo abrieras desde cualquier otro lado, estaba leyendo pero no pude implemtarlo.



No se preocupen por la capacidad que tiene este programa, pieso terminarlo para vacaciones, ya con menos presiones.

Eventos, excepciones y errores

Todos los try-catch siguientes, estan relaccionados con la base de datos, cada uno ellos interectua con la base de datos, para si hubo un error te lo muestre en el momento preciso y no despues.



try.catch para obtener el id del archivo posicionado


try-catch para conectar a la base de datos

try-catch para inizialisar el arreglo


try-catch para asegurar que nos podemos mover entre los archivos, ya estando dentro de visualizador



El filtro que se encarga para solo escojer "pdf o text"

Documentación técnica

Objetivo: Generar la documentación técnica del proyecto.

Todos los arhivos del programa podran encontrarlos aqui.

con JAVADOC

https://rapidshare.com/files/4064445313/javadoc-todo.zip

Auto-generación de código

Una diferencia grande es que, para mi programa yo use un actionPerfomed por cada botón que tenia, en el código auto-generado solo tenia uno, en donde abarca todo eso.

El código-autogenerado maneja un método get(), set() por cada atributo yo no lo hice tanto, solo tome la id del archivo y con ella tome el nombre y la ruta.

Declara las variables de los métodos "protected" tal ves pueda funcionar para un o das variables porque en mi caso todo es privado, pero pensando bien esa posibilidad podría ahorrar código, el cual por ser novato en java, si me lleve DEMASIADO código.

Ya viendo bien el codigo, si tiene varias ideas que se le pueden sacar probecho y es rocomendable hacer un diagrama antes de codificar.

Eventos, excepciones y errores

Detectar los eventos, excepciones y errores que se generan con su software.

Contenido esperado de la entrada: Tablas con la estructura que más abajo se detalla.

Eventos

Las funcionabilidades del sistema y sus reacciones.

Componente gráfico generador	Tipo de evento (presionar, soltar, pasar por encima de, etc.)	Acción que se dispara
Botón - Agregar Archivo	Abre una ventana nueva, en donde te muestra los campos a llenar.	Abre una nueva ventana
Botón - Ver Archivo	Abre una ventana nueva, en donde te muestra el nombre del archivo, y 4 botones (anterior, ver, eliminar, siguiente)	Abre una nueva ventana
Etiqueta - Datos Archivo	Muestra el titulo de la ventana	Ninguna
Etiqueta - Nombre	Muestra el nombre del campo	Ninguna
Campo de texto	Aquí tu puedes escribir el nombre de tu archivo.	Muestra la ruta de tu archivo
Área de texto	Agrega la ruta del archivo seleccionado,en este campo no puedes escribir, ni modificar.	Ninguno
Botón - Examinar	Muestra un ventana de seleccionar archivo, gracias a la librería JFIleChooser	Abre un nueva ventana para seleccionar el documento.
Botón - Guardar	Si lo campos están "llenos" te mostrara un mensaje de "archivo agregado" y si uno de los campos esta vació mostrara un mensaje de volver a intentar de nuevo.	Agrega el archivo a la base de datos
Botón - Cancelar	Sale de la ventana, volviendo a la pantalla principal	Regresa a la pantalla principal

Excepciones

Cuando pasa algo que no esta permitido.

Modo en que se genera	Manejo
Agregar un archivo no especificado	Un filtro para que no pueda agregar cosas no permitidas.
Sobrepasar el limite de capacidad (500 mg)	Poner un contador para la capacidad y si lo pasa, no agregar o eliminar.

Errores
Algo fuera de nuestro programa que pasa por accidente.

>

Modo en que se genera	Manejo
Dobles Usuarios (una persona intenta registrar una cuenta ya existente)	Tener un base de datos con los usuarios y contraseñas y usar una hashtable para buscar si ahí repetidos
Tener dobles inicios de sesion	Tener una especie de variable boleana que al entrar este en estado true y manteniendo el valor "true" para no permitir la entrada de nadie.

Agradecería sus comentarios, lo que sea para mejorar.

Retroalimentación

Objetivo: Dar y recibir retroalimentación por parte de sus compañeros.

Pequeña entrada donde estuvimos dando y recibiendo retroalimentación vía facebook es muy sencilla y tal ves poco formal pero si tocamos temas vistos en clase.

http://www.facebook.com/permalink.php?story_fbid=10150255815717300&id=613197299&notif_t=feed_comment_reply

Sistemas distribuidos aplicado al proyecto

Dividir el programa en partes para su mejor funcionamiento, como separar la base de datos del programa, para que no consumiera tanto recursos y en todo caso de que se dañara la información para que la base de datos (lo que importa) no se vea afectada.

Tener un servicio web en donde puedas aceder con tu usuario y contraseña, y ahi conectadno a la base de datos para guardar los archivos que quieras organizar o respaldar.

REFERENCIAS
http://www.monografias.com/trabajos16/sistemas-distribuidos/sistemas-distribuidos.shtml

Patrones de Diseño

Aun no entiendo muy bien los patrones de diseño lo cual hace que sea muy dificil de decidir si o no usarlos. pero en caso de ocuparlos serie el DELEGATION porque tengo varios metodos de otras clases que me gustaria usar en otras clases.

Una descripcion del Patrón DELEGATION:

Utilidad:
Cuando se quiere extender y reutilizar la funcionalidad de una clase SIN UTILIZAR LA HERENCIA
Ventajas:
• En vez de herencia múltiple
• Cuando una clase que hereda de otra quiere
ocultar algunos de los métodos heredados
• Compartir código que NO se puede heredar

El problema

El lenguaje utilizado NO PERMITE HERENCIA MÚLTIPLE
La clase C no desea TODOS los métodos de B

La solución

NO USAR HERENCIA SINO LA RELACIÓN “USA”

Implementación

classC extends A {
B objB;
C ( ) { // En la constructor se puede crear obj. de B
objB=new B();
}
void b1( ) { objB.b1( );}
…

REFERENCIAS

http://siul02.si.ehu.es/~alfredo/iso/06Patrones.pdf

Pruebas unitarias

¿Que son las pruebas unitarias?

Son pruebas dirigidas a probar clases java aisladamente y están relacionadas con el código y la
responsabilidad de cada clase y sus fragmentos de código más criticos.

¿Porque realizar pruebas unitarias?
1.- Asegura calidad del código entregado.
2.- Ayuda a definir los requerimientos y responsabilidades de cada método en cada clase probada.
3.- Constituye una buena forma de ejecutar pruebas de concepto.
4.- Permite hacer refactoring tempranamente en el código.
5.- Permite incluso hacer pruebas de estress tempranamente en el código.
6.- Permite encontrar errores o bugs tempranamente en el desarrollo.

Pruebas Unitarias del proyecto

Agregar Archivo
Ver Archivos


Eliminar Archivo



REFERENCIAS

http://blog.continuum.cl/wp-content/uploads/2008/08/pruebas-unitarias.pdf

Todos los comentaios son bienvenidos

Interfaces poco "bonitas"

Buscando información para esta entrada, me encontré con una pagina que da su punto de vista del porque es importante las interfaces grafías titulado "El UI no se puede dejar para después", lo leí y coincido con el lector varias cosas por las que el software deja de funcionar es por su mala interfaz gráfica y nos muestra una serie de pasos para que todo salga con éxito.

Aquí la pagina

Todos los artistas del mundo en una misma pagina
---------------------------------------------------------------

y... a donde le pico?
-----------------------------------------------------------------------------

Esta persona estaba muy cansada o en realidad no sabia diseñar.
--------------------------------------------------------------------------------------------

Esto me recuerda al juego "donde quedo la bolita"
-----------------------------------------------------------------------------------------

Sin duda ahí mas paginas como estas, pero lo menos se hubieran inspirado en otras con un buen diseño. artículo original

Demostración de avance parcial

Pequeña descripcion de las funciones del programa

JBotton, JPanel, JTextFiel, JTextArea: todos los use para el diseño de interfaz grafica al no manejar tantos datos, no uso tantas funcinabilidades.

actionPerformed(): para las acciones de cada boton con el click del mouse.

FlowLayout(): Para insertar los objetos a las ventanas sencillas y que no ocupen tanto

GridBagLayout(): para un acomadamiento mejor de los objetos que se agregaran a una ventana, se basa en dividir la ventana en columnas y asignarle cordenadas.

WindowListener(): todo lo que diga Window son metodos que sirven como caracteristicas que se le dan a las ventanas.

JFileChooser(): para seleccionar archivos, se lo puse al boton "examinar"

Especificación técnica

Lista de funcionalidades que aún no están completas.

-Hacer TODO del botón "Ver archivos"
incluye:
la funcionabilidad del botón siguiente
la funcionabilidad del botón anterior
la funcionabilidad del botón ver
la funcionabilidad del botón eliminar
y darles un buen diseño (acomodarlos)



Para cada funcionalidad, qué falta para completarla.

-funcionabilidad del botón siguiente: es hacer un método dentro de la misma clase para avanzar a al siguiente archivo.
-funcionabilidad del botón anterior: igual que el botón siguiente también un método para inicializar desde el primer archivo.
-la funcinabilidad ver y eliminar ambos botones se deben interactuar con la base de datos para aceder a los archivos

      /*----------------------------------
                 BOTON ANTERIOR
      -------------------------------------*/
     ActionListener accionAnterior = new ActionListener()
     {
         public void actionPerformed( ActionEvent evt )
         {
            anterior();//Va al anterior registro de la tabla
         }
     };
     botonAnterior.addActionListener( accionAnterior );

     /*----------------------------------
                BOTON SIGUIENTE
     -------------------------------------*/
     ActionListener accionSiguiente = new ActionListener()
     {
         public void actionPerformed( ActionEvent evt )
         {
            siguiente();//Va al siguiente registro de la tabla
         }
     };
     botonSiguiente.addActionListener( accionSiguiente );
       

( aun falta hacer los métodos anterior() y siguiente() )

Para cada funcionalidad, qué van a hacer para terminarla.

Para los botones siguiente y anterior nadamas un método que sirva para ver los registros (archivos en la tabla) pienso en un if y un while para contar los registros

Para el botón ver y eliminar, un amigo Abraham me explicara un poco se como hacerlo y yo base a la idea trabajare, lo mas seguro es un método pero es mejor si un amigo te explica.

Demostración de avance parcial

Bueno tras leer un BUEN rato y platicar con amigos Abraham,Pedro y Obed, avanze lo que hasta ahora llevo ( se que no es mucho, pero es algo ):

Ventana Principal sencilla pero entendible

Codigo:

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

public class Principal extends JFrame
{
//Constructor
public Principal()
{
 Container c = getContentPane();
 c.setLayout(new FlowLayout());

 //Establecer titulo, tamanio y posicion en la ventana 
 setSize(400,100);
 setLocationRelativeTo(null);//centrado
 setResizable(false);//no maximizar ni cambiar tamaño

 //Crear el boton Agregar
 JButton botonAgregar = new JButton("Agregar Archivo");
 JPanel panAgregar = new JPanel(new FlowLayout());
 panAgregar.add(botonAgregar);

 //Crear el boton para abrir el visor
 JButton botonVisor = new JButton("Ver Archivos");
 JPanel panVisor = new JPanel(new FlowLayout());
 panVisor.add(botonVisor);
 
 c.add(panAgregar);
 c.add(panVisor);

 //Al dar en la X terminar todo el programa
 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

 //------------ACCION DEL BOTON AGREGAR ARCHIVO--------------//
     ActionListener ActionAgregar = new ActionListener()
     {
  public void actionPerformed(ActionEvent evt)
  {
      AltaArchivos ejemplo = new AltaArchivos(400,200);
      ejemplo.mostrar();
      //Ocultar la ventana principal
      setVisible(false);
  }
 };
 botonAgregar.addActionListener(ActionAgregar);
 //--------FIN DE LA ACCION DEL BOTON AGREGAR ARCHIVO--------//

}//fin del contructor

public void mostrar()//para mostrar la ventana
{
 setVisible(true);
}//Fin del metodo mostrar

public static void main( String args[] )
 {
 Principal ejemplo = new Principal();
 ejemplo.mostrar();
 }//Fin del main
}//Fin de la clase Principal

Agregar Archivo y mensajes de aviso

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.File;
import java.sql.*;


public class AltaArchivos extends JFrame
{

JTextArea areaRutaImagen; //Para Introducir texto
JTextField textoNombre; //Para introducir datos

private static
Connection con = null;   //Variable para la conexion
Statement st; //Consultas      

//Constructor
public AltaArchivos( int ancho, int alto )
{
 //Ventana
 Container ventana = getContentPane();
 ventana.setLayout( new FlowLayout() );

 setSize(ancho,alto);//tamaño de la ventana
 setLocationRelativeTo( null );//Lugar de inicio de la ventana null=centro
 setResizable( false );//No cambiar de tamaño, ni agrandar

 //(Etiqueta) Titulo de la ventana
 JLabel Titulo = new JLabel( "Datos del Archivo" );

 //CARacteriticas de la etiqueta titulo
 JPanel CARTitulo = new JPanel(new FlowLayout( FlowLayout.CENTER ));
 CARTitulo.add(Titulo);
 ventana.add( CARTitulo );//Agregar a la ventana

 // (Etiqueta) Nombre y su campo de texto para agregar la ruta del archivo
 JLabel Nombre = new JLabel( "Nombre: " ); //Nombre de la etiqueta
 textoNombre = new JTextField( 20 ); //Espacios totales del campo de texto

 //CARacteriticas de la etiqueta nombre
 JPanel CARNombre = new JPanel( new FlowLayout( FlowLayout.LEFT ) ); //El FlowLatout sirve para posicionar
 CARNombre.add( Nombre );
 CARNombre.add( textoNombre );
 ventana.add( CARNombre );//Agregar a la ventana

 //Crear el boton examinar
 JButton botonExaminar = new JButton( "Examinar..." );//Nombre del boton examinar
 botonExaminar.addActionListener( new seleccionarImagen() );

 //Crear el area de texto para mostrar la ruta absoluta del archivo
 JPanel rutaImagen = new JPanel( new FlowLayout( FlowLayout.LEFT ) );
 //Metodos de JTextArea
 areaRutaImagen = new JTextArea( 2,20 );
 areaRutaImagen.setDisabledTextColor( Color.RED );
 areaRutaImagen.setLineWrap( false ); //Para tener toda la ruta en una misma linea
 areaRutaImagen.setEnabled( false ); //Para desabilitar la 1ra ventana

 //Un scroll( barra deslizante )
 JScrollPane scrollRutaImagen = new JScrollPane( areaRutaImagen );//crea un Scroll y como parametro la "areaRutaImagen"
 scrollRutaImagen.getHorizontalScrollBarPolicy();//Metodo que indica que se posicionara de forma horizontal
 rutaImagen.add(scrollRutaImagen);//Es agregado a "areaRutaImagen" para poder ver
           //la ruta completa, porque sino solo veriamos una parte
 rutaImagen.add(botonExaminar);
 ventana.add( rutaImagen );//Agregar a la ventana

 //Crear el boton guardar
 JButton botonGuardar = new JButton( "Guardar" );
 //CARacteriticas del boton guardar
 JPanel CARGuardar = new JPanel( new FlowLayout( FlowLayout.CENTER ) );//El FlowLatout sirve para posicionar
 CARGuardar.add( botonGuardar );
 ventana.add( botonGuardar );//Agregar a la ventana

 //Crear el boton cancelar
 JButton botonCancelar = new JButton( "Cancelar" );//Nombre del boton cancelar
 //CARacteriticas del boton cancelar
 JPanel CARCancelar = new JPanel( new FlowLayout( FlowLayout.CENTER ) );//El FlowLatout sirve para posicionar
 CARCancelar.add( botonCancelar );
 ventana.add( botonCancelar );//Agregar a la ventana


 //---------Barra de la ventana----------//
//Para que al dar clic en la x de la esquina de este JFrame
 //se muestre por default la ventana principal
 this.addWindowListener( new WindowAdapter() //Agrega que el oyente ventana especificada
            //para recibir eventos de ventana de la ventana.
 {
  public void windowClosing( WindowEvent e ) //para no salir de la aplicacion cerrando la ultima ventana
  {
   Principal ejemplo = new Principal(  );
        ejemplo.mostrar();
   setVisible( false );//ocultar la ventana, si no simpre estaria abierta
  }
 } );

 //-------------Boton cancelar-------------//
ActionListener accionCancelar = new ActionListener()
{
public void actionPerformed( ActionEvent evt )
{
   Principal ejemplo = new Principal(  );//Crea un objeto de la clase Principal
   ejemplo.mostrar();//llama al metodo de la clase Principal
   setVisible( false );//ocultar la ventana, si no simpre estaria abierta
}
};
botonCancelar.addActionListener( accionCancelar );

//-------------Boton guardar-------------//
ActionListener accionGuardar = new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
 //Validar que NO haya campos vacios
    if( camposVacios() )//Llama el metodo camposVacios
     {
        JOptionPane.showMessageDialog( null,"Hay campos vacios. Intenta de nuevo." );
        return;
      }//Fin del if hayCamposVacios()

    if( conectarBaseDatos() )//Llamada al metodo
    {
         if( altaProducto() )//Llamada al metodo
          {
          JOptionPane.showMessageDialog( null,"Producto guardado con exito" );
          textoNombre.setText("");
          areaRutaImagen.setText("");
          }//Fin del if altaProducto
         else
           JOptionPane.showMessageDialog( null,"No se pudo guardar" );
   }//Fin del if conectarBaseDatos()
   else
      JOptionPane.showMessageDialog( null,"No se pudo Conectar la BD" );

}//Fin del metodo actionPerformed
};
botonGuardar.addActionListener( accionGuardar );

}//Fin del costructor


//Conectar a la base de datos
public boolean conectarBaseDatos()
{
try
{
Class.forName( "com.mysql.jdbc.Driver" );
String strCadenaConexion = "jdbc:mysql://localhost/pruebaRuta";
con = DriverManager.getConnection( strCadenaConexion,"root","celeron" );
if ( con == null )
   return false;

st = con.createStatement();
return true;
}catch(SQLException sqlex)
{
sqlex.printStackTrace();
 return false;
}//Fin del catch SQLException sqlex
catch( Exception e )
{
e.printStackTrace();
return false;
}//Fin del catch Exception e
}//Fin del metodo conectarBaseDatos

//Agrega un archivo a la tabla productos
public boolean altaProducto()
{
try
{
int res = st.executeUpdate( "INSERT INTO " +
  "productos(nombre,imagen) VALUES('"+textoNombre.getText()+"','"
  +areaRutaImagen.getText()+"')" );
if( res==1 )
   return true;

else
   return false;

}catch( SQLException sqlex )
{
sqlex.printStackTrace();
 return false;
}//Fin del catch SQLException sqlex
catch( Exception e )
{
e.printStackTrace();
return false;
}//Fin del catch Exception e
}//Fin del metodo altaProducto

//Comprueba true si alguno de los 2 campos esta vacios
public boolean camposVacios()
{
if( textoNombre.getText().isEmpty() || areaRutaImagen.getText().isEmpty() )
return true;

return false;
}

//hace visible la ventana
public void mostrar()
{
 setVisible( true );
}

//Clase interna
class seleccionarImagen implements ActionListener
{
  public void actionPerformed( ActionEvent ae )
  {
    String archivoSeleccionado;
    JFileChooser SeleccionarArchivo = new JFileChooser();
    //llama a la calse filtro
    SeleccionarArchivo.addChoosableFileFilter( new Filtro() );
    //Filtro a usarse por defecto
    SeleccionarArchivo.setFileFilter(SeleccionarArchivo.getChoosableFileFilters()[1]);

      //abre la ventana abrir
      int select = SeleccionarArchivo.showOpenDialog( AltaArchivos.this );
      if ( select == JFileChooser.APPROVE_OPTION )
      {
          File filSeleccionado = SeleccionarArchivo.getSelectedFile();
          archivoSeleccionado = filSeleccionado.getAbsolutePath();//metodo para obtener la ruta raiz
          //muestra la ruta raiz en la area de texto
          areaRutaImagen.setText( archivoSeleccionado );
      }//Fin de if retval == JFileChooser.APPROVE_OPTION
  }//Fin del metodo actionPerformed
}//Fin de clase interna

}//Fin de la clase

Aun tengo que hacer funcionar el boton Ver Archivos y todos sus complementos, para el jueves pienso tenerlo, saludos

Herencia y polimorfismo

Herencia y polimorfismo

A estas alturas no usare herencia me enfocare a terminar lo que ya comencé, para tenerlo terminado, eliminando así mi única herencia de "usuario".

Esqueleto del software

Que tal, ahora vamos a resumir lo que es el esqueleto del software y para que sirve.

¿Que es?
Es un paso antes de codificar, donde según tu lenguaje, empiezas a codificar solo los contructores, métodos, variables, etc. dejando a un lado la parte lógica, solo nos importa la estructura que llevara osea el esqueleto que tendrá.

¿Para que sirve?
Te da una visión mas profunda a como estará diseñada tu codificación, y al empezar de 0, este ejercicio es muy útil.

Esqueleto de mi programa:

Clase Principal:

public class Principal extends JFrame
{
 //Constructor
 public Principal()
 { 
 }//fin del contructor

 public void mostrar()//para mostrar la ventana
 {
 }//Fin del metodo mostrar

 public static void main( String args[] )
  {
   }//Fin del main
}//Fin de la clase Principal

Clase Alta Archivos

public class AltaArchivos extends JFrame
{

 JTextArea areaRutaImagen; //Para Introducir texto
 JTextField textoNombre; //Para introducir datos


 private static Connection con = null;   //Variable para la conexion
 private static Statement st; //Consultas       

 //Constructor
 public AltaArchivos( int ancho, int alto )
 {
 }//Fin del costructor


 //Conectar a la base de datos
 public boolean conectarBaseDatos()
 {
 }//Fin del metodo altaProducto

 //Comprueba true si alguno de los 2 campos esta vacios
 public boolean camposVacios()
 {
 }

 //hace visible la ventana
 public void mostrar()
 {
 }

 //Clase interna
 class seleccionarImagen implements ActionListener
 {
 }//Fin de clase interna

}//Fin de la clase

Clase Visualiador

public class Visualizador extends JFrame
{

 public Visualizador( int ancho, int alto)
 {
 }//Fin del constructor

 public void inicializar()
 {
 }//Fin del metodo inicializar()


 public void anterior()
 {
 }//anterior()


 public void siguiente()
 {
 }//siguiente()


 public boolean conectarBaseDatos()
 {
 }//Fin del metodo conectarBaseDatos()


 public void mostrar()
 { 
 }//fin del metodo mostrar ()

}//Fin de la clase

Al final Actualizare esta entrada para que vean el esqueleto terminado ( pienso que aun me falta un método ).

Importancia de la documentación tecnica

Mi explicación:

Imagina que estas perdido en un isla tu solo, ¿que haces primero?, ¿hacer una fogata?, ¿construir una base?, ¿ir por comida?, ¿hacer una balsa?, ¿a cual darle mayor importancia? seguro, te basaras en tus instintos y lo conseguirás, pero...y todo el tiempo que te llego pensar eso, todo el tiempo que te toco buscar la comida, todo el tiempo que intentaste buscar los mejores troncos para tu base, sin duda, tiempo muy valioso y si se trata de una empresa también costoso, que no te gustaría perder, pero si tuberías un mapa e instrucciones para "Aprenda a sobrevivir en una isla en 3 días", FACILISIMO no?

Por eso la importancia de la documentación técnica, es fundamental y te ahorra lo mas preciado en la vida el "tiempo".
Tal vez digas: "lo haré de la forma mas fácil, pero lo mas fácil para que todos entiendan", y no dudo que lo hagas, de echo es lo que todos queremos al hacer cualquier cosa(claro, sencillo y eficiente) pero quien no ha batallado con una televisión, buscando entradas, botones, etc. incluso hasta con el control remoto.

Y si esto causara perdidas, en que el usuario dejara de usar tu "creación" solo porque no sabe como funciona! si duda te daría coraje y le dirías de TODO, pero de eso no se trata, el objetivo es que las cosas sean sencillas de manejar en cualquier punto de nuestra vida.



REFERENCIAS

http://www.desarrolloweb.com/articulos/importancia-documentacion.html

Diseño de interfaces graficas en el proyecto

Que tal, a continuación les mostrare las ventanas de mi sistema




Como ventana principal habrá 2 botones
Nuevo: para agregar un nuevo archivo.

Ver: para ver los archivos contenidos.







Al hacer click en nuevo te mandara a otra ventana con dos JLabel, un JTextField para que el usuario le ponga el nombre al archivo, un JTextArea para mostrar la ruta del archivo y 3 JBotton ("Examinar...", "Guardar", "Cancelar").






Al hacer click en Guardar te mostrara un mensaje de confirmación pero si llegaras a dejar un campo vació y le das aceptar te mostrara una advertencia y podrás corregir.



Al hacer click en "Examinar..." aparecera por default una ventana paracida a cuando eliges un archivo esto grasias JFileChooser.




La ventana de mostrar archivos aun estoy pensandola porque el tiempo que tenemos es corto y aun nose muy bien todas las caracteristicas necesarias para hacerla, comprometerme seria talves no llegar a cumplir, pero esta es un idea muy sencilla talves no sea la mejor porque al tener 100 imagenes tendras que hacer 100 click.

Diagramas de Secuencia

¿Que son?

El diagrama de secuencia es un tipo de diagrama usado para la interacción entre objetos en un sistema.

EL diagrama de secuencia es dividir cada caso de uso por funcionabilidad y detallar todos los procesos con el cual se ve involucrado la acción, con que clases interactúa, el escenario, los métodos(mensajes) que se necesitan para ejecutar las acciones y los actores(personas) involucrados.

¿Para que sirven?

Sirve para la interacción de de un conjunto de objetos de un sistema a través del tiempo y se modela para cada caso de uso. El diagrama de secuencia es un vista de que hará que a la hora de probar el sistema.

Así, en el caso de una aplicación para jugar al buscaminas, se podrían realizar
diagramas de secuencia para “jugar una partida” o bien para acciones más específicas como“marcar casilla”.

El detalle que se muestre en el diagrama de secuencia debe estar relacionado con lo que se intenta mostrar o bien con la fase de desarrollo en la que esté el proyecto, no es lo mismo un diagrama de secuencia que muestre la acción de "mover pieza" a otro que sea "mover caballo", en el caso de un tablero de ajedrez.

El detalle del diagrama depende de la fase en la que estemos, lo que pretendamos contar con el diagrama y a quién.
Diagrama se secuencia del proyecto

Ver archivo
Actor: Usuario
Clases involucradas: ver ventana, visualizador
Metodos: pedirImeagen(), mostrarArchivo()

Eliminar Archivo
Actor: usuario
Clases involucradas: ventana principal, eliminar, visualizador.
Métodos: verArchivos(), EliminarArchivos(), refrescar().

Agregar Archivo
Actor: Usuario
Clases involucradas: ventana principal, carga, filtro
Métodos: agregar(), aceptarImagen(), filtrar().

REFERENCIAS:

http://es.wikipedia.org/wiki/Diagrama_de_secuencia

http://www2.uah.es/jcaceres/uploaded/capsulas/DiagramaSecuencia.pdf

Interfaces en java

¿Concepto de Interface?

El concepto de Interface lleva un paso más adelante la idea de las clases abstractas. En Java una interface es una clase abstracta pura, es decir una clase donde todos los métodos son abstractos (no se implementa ninguno). Permite al diseñador de clases establecer la forma de una clase (nombres de métodos, listas de argumentos y tipos de retorno, pero no bloques de código). Una interface puede también contener datos miembro, pero estos son siempre static y final. Una interface sirve para establecer un 'protocolo' entre clases.

¿Porque utilizar interfaces?

Para revelar la interfaz de un objeto de programación (funcionalidad del objeto) sin revelar su ejecución.
- Este es el concepto de encapsulación
- La puesta en práctica puede cambiar sin afectar el que llama a la interfaz.

Para que las clases no relacionadas implementar similares métodos (comportamientos).

Declaración y uso

Una interface se declara:

       interface nombre_interface {
tipo_retorno nombre_metodo ( lista_argumentos ) ;
. . .
}

Por ejemplo:

       interface InstrumentoMusical {
void tocar();
void afinar();
String tipoInstrumento();
}

Y una clase que implementa la interface:

       class InstrumentoViento extends Object implements InstrumentoMusical {
void tocar() { . . . };
void afinar() { . . .};
String tipoInstrumento() {}
}

class Guitarra extends InstrumentoViento {
String tipoInstrumento() {
return "Guitarra";
}
}

La clase InstrumentoViento implementa la interface, declarando los métodos y escribiendo el código correspondiente. Una clase derivada puede también redefinir si es necesario alguno de los métodos de la interface.

REFERENCIAS

http://www.arrakis.es/~abelp/ApuntesJava/Interfaces.htm

http://www.cpe.eng.cmu.ac.th/wp-content/uploads/javainterface.pdf

Sistemas de casos fallidos

Ahi en CIOInsight un artículo acerca de la experiencia de una persona en la resolución de proyectos con riesgo de fracaso y en el que aporta algunas sugerencias sobre qué camino seguir y cuál no (explicando un proyecto que no pudieron rescatar). Seguro que más de uno se siente identificado como bombero o paracaidista de proyectos, que es justo lo contrario de lo que pretende defender el autor. Algunas pistas incluyen seguir contando con el equipo de proyecto existente en la medida de lo posible, evitar hacer al equipo realizar un esfuerzo extra buscando formas de trabajar más inteligentes y productivas o elegir las batallas que se pueden ganar o los proyectos cuya solución se puede abordar.

La siguiente gráfica muestra una presentación con los resultados de una encuesta, acerca de las razones que llevaron a cancelar proyectos IT.


Las principales causas de cierre de proyectos 1) el cambio de necesidades de negocio, 2) la incapacidad del proyecto de cumplir las expectativas prometidas, 3) cambio en las prioridades, 4) sobrepasar el presupuesto y 5) que el proyecto no estaba alineado con el negocio.

Un ganador se compromete; un perdedor hace promesas.


REFERENCIAS

http://www.businessweek.com/managing/content/may2008/ca20080529_123818.htm

http://www.cioinsight.com/c/a/Management/Why-IT-Projects-Get-Killed/

Diagrama de clases

Primero, ¿Que son los diagramas de clase? ¿para que se usa? y ¿porque son necesarios?. Investiguemos un poco acerca de estas preguntas...

¿Que son los diagramas de clase?

El diagrama de clase representa clases, sus partes y la forma en la que las clases de los objetos están relacionados con otro.

¿Para que se usa?

Es el más utilizado y más conocido de los diagramas orientados a objetos. Es la fuente de generación de código.

¿Porque son necesarios?

Para tener una idea de lo que se hará en el programa. Es la base de la codificación.

Diagrama de clases del proyecto


cadit.anahuac.mx/~sac/download/.../DIAGRAMADECLASE_20090223.ppt

http://es.wikipedia.org/wiki/Diagrama_de_clases


Dudas, sugerencias, un error que pude aver cometido. comentar :D

Herencia y Polimorfismo

Vamos hablar un poco de lo que trata sus definiciones:

Herencia

Es una propiedad que permite que los objetos sean creados a partir de otros ya existentes, obteniendo características (métodos y atributos) similares a los ya existentes.

Ejemplo:

-El perro y el gato tendrían la herencia (métodos y atributos del Mamífero).

Polimorfismo

Es la capacidad que tiene los objetos de una clase de responder al mismo mensaje o evento en función de los parámetros utilizados durante su invocación.

Hay dos tipos:

Dinámico: es el que el código no incluye ningún tipo de especificación sobre el tipo de datos.

Estático: es el que los tipos a los que se aplica el polimorfismo deben ser explícitos y declarados uno por uno antes de ser utilizados.


En el caso del proyecto:

La HERENCIA no es aplicada en mi proyecto porque no hay una clase Padre, los metodos se sobrecargan pero no se heradan nada

POLIMORFISMO, si usare polimorfismo, en los tipos de datos para sobrecargar la mayoría de los métodos con los tipos de archivo, nombre de los archivos, el tamaño del archivo. sobre cargare el operador de suma (+) y los constructores.

REFERENCIAS:

http://www.slideshare.net/equipo2/poo-herencia-abstraccion-y-polimorfismo

http://es.wikipedia.org/wiki/Polimorfismo_%28programaci%C3%B3n_orientada_a_objetos%29

Diseño de Clases

Que tal, hoy tratare de dar una breve introducción a "Diagramas de clase" y contestar las preguntas que vallan surgiendo.

¿Que es un Diseño de Clases?

Mi explicación: Es un tipo de "mapa conceptual" en donde están relacionados todas aquellas clases y métodos según su interacción y funcionalidad, mostrando sus atributos y visibilidad.

Explicación de Internet: Un diagrama de clases es un tipo de diagrama estático que describe la estructura de un sistema mostrando sus clases, atributos y las relaciones entre ellos.

Ahora, ¿Para que se usan?

Son utilizados durante el proceso de análisis y diseño de los sistemas, donde se crea el diseño conceptual de la información que se manejará en el sistema, y los componentes que se encargaran del funcionamiento y la relación entre uno y otro.

EJEMPLO:

Ahora que ya tenemos la definición de lo que es, ¿como sabríamos que nuestro diseño es el correcto?

Les presentare unos "síntomas" para saberlo

RIGIDEZ ( las clases son difíciles de cambiar );
FRAGILIDAD ( es fácil que las clases dejen de funcionar );
INMOVILIDAD ( las clases son difíciles de utilizar );
VISCOSIDAD ( resulta difícil utilizar las clases correctamente );
COMPLEJIDAD INNECESARIA ( abuso de copiar y pegar );
OPACIDAD ( aparente desorganización );

y si ahí "síntomas" también ahí "medicinas". Les presentare algunas para prevenir/eliminar los "síntomas" de arriba.

PRINCIPIO DE RESPONSABILIDAD ÚNICA ( una clase debe utilizar un único motivo para cambiar );
PRINCIPIO ABIERTO-CERRADO ( los módulos deben ser ala vez abiertos y cerrados: abiertos para ser extendidos y cerrados para ser usados );
PRINCIPIO DE SUSTITUCIÓN DE LISKOV ( los caso base siempre se pueden sustituir pos sus subtipos );
PRINCIPIO DE INVERSIÓN DE DEPENDENCIAS ( [a] Los módulos de alto nivel no deben depender de módulos de bajo nivel. Ambos deben depender de abstracciones [b] Las abstracciones no deben depender de los detalles. Los detalles deben depender de las abstracciones );

DIAGRAMA APLICADO EN MI PROYECTO


1.- CLASE:
[+]usuario
ATRIBUTOS:
[-]nombre, [-]contraseña
MÉTODOS:
[+]login(), [+]logOut(), [+]registrarse();

2.- CLASE:
[+]visualizador
ATRIBUTOS:
[-]ruta, [-]string, [-]id
MÉTODOS:
[+]siguiente(), [+]anterior(), [+]consultar(), [+]campos vacios, [+]inicializar();

3.- CLASE:
[+]ventana principal
MÉTODOS:
[+]mostrar(), [+]actionPerdomed();

4.- CLASE:
[+]baseDatos
MÉTODOS:
[+]conexion(), [+]getSt();

5.- CLASE:
[+]altaArchivo
ATRIBUTOS:
[-]ruta, [-]string, [-]id
MÉTODOS:
[+]actionPerfomed(), [+]guardarArchivos(), [+]camposVacios, [+]campos vacios, [+]eliminar();

6.- CLASE:
[+]filtro
MÉTODOS:
[+]aceptar();

7.- CLASE:
[+]directorio
MÉTODOS:
[+]actionPerfomed();


Lo que esta entre corchetes es el tipo de visibilidad

REFERENCIAS

http://es.wikipedia.org/wiki/Diagrama_de_clases

http://elvex.ugr.es/decsai/java/pdf/AB-classes.pdf

Dudas, sugerencias y/o comentarios aqui abajo :D