Interfaz Gráfica

**Entrega 3** - Modificada

•     Añadí el código fuente de la interfaz.

Hola a todos , esta entrada es para mostrar mi interfaz gráfica, aun faltan algunas cosas como el manejo de JTable e imágenes.

Sin mas que decir utilicé 4 botones, 5 Labels (etiquetas)  , y el menú. No tiene ventanas adicionales, solo la que se muestra en pantalla.

Interfaz

Código Fuente de la ventana:

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


public class Interfaz extends JFrame {
 
    private JPanel panel_2;
    private JButton btn_agregar;
    private JButton btn_modificar;
    private JButton btn_borrar;
    private JButton btn_mover;
    private JLabel label_nom;
    private JLabel label_tipo;
    private JLabel label_dir;
    private JLabel label_cump;
    private JLabel label_tel;
    private MenuBar barra = new MenuBar();
    private Menu archivo = new Menu ("Archivo");
    private Menu opciones = new Menu ("Opciones");
    
    public Interfaz() 
    { 
     this.setTitle("Interfaz Grafica");
     this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     this.definir();
     this.setSize (650,400);
     this.setVisible(true);
    }
    
    public void definir()
    {
      /**Barra de Menu*/
        setMenuBar(barra);
        barra.add(archivo);
        barra.add(opciones);
        archivo.add("Nuevo");
        archivo.add("Abrir");
        archivo.addSeparator();
        archivo.add("Guardar");
        archivo.add("Exportar");
      
       getContentPane().setLayout(null);

        /**Botones*/
        btn_agregar = new JButton("Agregar");
        this.add(btn_agregar);
        btn_agregar.setBounds(75,48,100,32);
        
        btn_modificar = new JButton("Modificar");
        this.add(btn_modificar);
        btn_modificar.setBounds(180,48,100,32);
        
        btn_borrar = new JButton("Borrar");
        this.add(btn_borrar);
        btn_borrar.setBounds(75,88,100,32);
        
        btn_mover = new JButton("Mover");
        this.add(btn_mover);
        btn_mover.setBounds(180,88,100,32);
        
        label_nom = new JLabel("Nombre:");
        this.add(label_nom);
        label_nom.setBounds(288,48,168,24);
        
        label_tipo = new JLabel("Tipo de Contacto:");
        this.add(label_tipo);
        label_tipo.setBounds(288,80,168,24);
        
        label_dir = new JLabel("Direccion:");
        this.add(label_dir);
        label_dir.setBounds(288,112,168,24);
        
        label_cump = new JLabel("Fecha de nacimiento");
        this.add(label_cump);
        label_cump.setBounds(288,144,168,24);
        
        label_tel = new JLabel("Telefono:");
        this.add(label_tel);
        label_tel.setBounds(288,176,168,24);
        
        panel_2 = new JPanel();
        this.add(panel_2);
        panel_2.setBounds(0,0,688,416); 
    }
    
 public static void main(String [] args) {
        Interfaz ventana = new Interfaz();       
  
    }
}

Nota: Ese código es solo de la interfaz sin que haya alguna acción en los botones.

Herencia y Polimorfismo

**Entrega 2**

Buenos días, en esta entrada hablaré sobre la herencia y el polimorfismo aplicado a mi proyecto, a continuación unas breves definiciones de lo que es:

Herencia

La herencia es uno de los mecanismos de la programación orientada a objetos, por medio del cual una clase se deriva de otra, llamada entonces clase base o clase padre,(a veces se le denomina superclase pero no es muy comun), de manera que extiende su funcionalidad. Una de sus funciones más importantes es la de proveer Polimorfismo y late binding.

En orientación a objetos la herencia es el mecanismo fundamental para implementar la reutilización y extensibilidad del software. A través de ella los diseñadores pueden construir nuevas clases partiendo de una jerarquía de clases ya existente (comprobadas y verificadas) evitando con ello el rediseño, la modificación y verificación de la parte ya implementada. La herencia facilita la creación de objetos a partir de otros ya existentes, obteniendo características (métodos y atributos) similares a los ya existentes.

Polimorfismo

En programación orientada a objetos el polimorfismo se refiere a la capacidad para que varias clases derivadas de una antecesora utilicen un mismo método de forma diferente.

Se puede clasificar el polimorfismo en dos grandes clases:

• Polimorfismo dinámico (o polimorfismo paramétrico): es aquél en el que el código no incluye ningún tipo de especificación sobre el tipo de datos sobre el que se trabaja. Así, puede ser utilizado a todo tipo de datos compatible.

• Polimorfismo estático (o polimorfismo ad hoc): es aquél en el que los tipos a los que se aplica el polimorfismo deben ser explicitados y declarados uno por uno antes de poder ser utilizados.

Entonces la herencia permite que los atributos y métodos de una clase "padre" puedan ser "heredados" o incorporados a clases "hijas", ademas de esto las clases hijas pueden tener sus métodos y atributos aparte de los que les fueron heredados.  Con respecto a polimorfismo, es el uso de estos métodos heredados de una clase "padre"  pero haciendo uso de estos métodos de una manera diferente.

Herencia y Polimorfismo en mi proyecto

En mi proyecto actualmente con lo que llevo no he aplicado herencia y tengo pensado no usarla porque solo manejare una clase llamada "Contacto" que tendrá los mismos atributos para cada objeto que sea contacto. No habrá atributos o métodos que un objeto si tenga y que otro objeto no.

El polimorfismo al igual que la herencia por el momento aun no tengo pensado implementarlo en mi proyecto, ya que los métodos que estoy usando hasta ahora son de la misma clase y todos los objetos de esta clase usarán de la misma manera los métodos.

Fuentes:

Herencia

Polimorfismo

Nota Actual

Esta entrada ya la tenía hecha, pero no la había subido porque no estaba seguro si ocuparía algo de herencia o polimorfismo en relacion con la clase contacto, que era la unica que manejaba, pero con el proyecto ya terminado solo la utilice para la creación de las ventanas, aplicada de este modo:

Para la ventana principal

public class Interfaz extends JFrame implements  ActionListener
{
 static int id;
 static String numero;
 static boolean recarga = false;
 static int indx = 0;
 
       private JPanel panel_2;
       private JButton btn_agregar;
       private JButton btn_modificar;
       .
       .
       .

Para la ventana agregar

public class agregar extends JFrame implements ActionListener{
 
    private JLabel nombre;
    private JLabel apellido;
    private JTextField txt_nombre;
    private JTextField apellido1;
    private JTextField apellido2;
    .
    .
    . 

Para la ventana Modificar

public class modificar extends JFrame implements ActionListener{
 
    private JLabel nombre;
    private JLabel apellido;
    private JTextField txt_nombre;
    private JTextField apellido1;
    private JTextField apellido2;
    .
    .
    .


    

Documentación Técnica

**Entrega 2**

JavaDoc

Javadoc es una utilidad de Oracle para la generación de documentación de APIs en formato HTML a partir de código fuente Java. Javadoc es el estándar de la industria para documentar clases de Java. La mayoría de los IDEs los generan automáticamente.

Mi documentación técnica la realicé con el software JavaDoc, con base a mis archivos de clase de código fuente. Utilicé este software porque considero que es sencillo y genera una buena documentación .

Para poderla realizar primero abrí la terminal, me desplace hacia la carpeta donde tenia el código de mi proyecto y utilicé el comando javadoc *.java y empezó a generar la documentación.

Generó varios archivos HTML de los cuales el principal es el "index" en donde se muestra la lista de las clases, su descripción, entre otras cosas.

Al abrir el archivo index apareció la siguiente pantalla donde se puede apreciar mejor lo anteriormente mencionado:

Captura de mi Documentación Técnica

Enlace de Descarga:

• Documentación Técnica

Referencias:

http://es.wikipedia.org/wiki/Javadoc  - Javadoc

Autogeneración de Código y Diagrama UML

**Entrega 2**

Hola a todos , esta entrada es sobre la auto generación de código de mi proyecto y el diagrama UML que elaboré para esto con el software Umbrello.

DIAGRAMA UML

El diagrama consta básicamente de 2 clases + 3 que son importadas.

Inicio: Contiene la clase Main y maneja la información con respecto a la clase Contacto.

Contacto: Es la clase con la que se maneja la información de un contacto, atributos, constructor , métodos.

Scanner: Es una clase importada para lectura de teclado.

FileWriter y PrintWriter: Son clases de la librería "java.io"para el manejo de archivos.

Código

Después de generar el código usando el asistente, este fue el resultado.  Básicamente las únicas clases que importan son la de inicio y contacto.

Vista Previa de la clase Inicio

Vista Previa de la clase Contacto

Observaciones y Comparación con mi código

El código que obtuve mediante el diagrama UML era similar al que hice, como por ejemplo las variables, y la estructura. Las diferencias fueron las siguientes:

• En los métodos, se generaron un método "get" y otro método "set", en los métodos que yo utilicé solo eran para recibir información de una clase y no para modificarla.

• Las notas que agregué en el diagrama las convirtió en comentarios para usarlas en la  documentación utilizando el doble asterisco ** y agregó notas como "@return the value of nombre" para indicar que el método regresaba la variable "nombre" y algunas otras, para facilitar la documentación técnica.

• Se Agregaron algunas descripciones en inglés sobre los métodos y añadió notas como cuales eran las clases, el constructor y los métodos.

Conclusión

Me pareció interesante utilizar la autogeneración del código ya que de esta manera se genera rápidamente un  esqueleto del programa,  esto ayuda a  agilizar el proceso de programar  teniendo previamente las clases y métodos, ya solo haría faltaría añadir las instrucciones de los métodos.

Clase Moto (Puntos Extra)

**Entrega 1** - Entrada Corregida - Puntos Extra

• Eliminado el Pseudo-código, se agrego el código del programa.

Este es el código de la tarea de la moto para puntos extras en taller:

Clase moto

public class moto 
{
 
private String placa; 
private boolean motor; //Encencido o apagado
private int velocidad = 0; //Inicia en 0 , termina en 300
private int bateria = 200; 

//Constructor de la clase moto
public moto(String placa, boolean motor , int velocidad, int bateria)
{
 this.placa = placa;
 this.motor = motor;
 this.velocidad = velocidad;
 this.bateria = bateria;
}

//Metodos
//Regresa un String con el valor de la placa
public String ret_placa() 
{
  return placa;
}

//Regresa el valor del estado del motor
public boolean ret_motor() 
{
 return motor;
}

//Regresa la velocidad de la moto
public int ret_velocidad() 
{
 return velocidad;
}

//Regresa el valor de la bateria
public int ret_bateria() 
{
 return bateria;
}

//Metodo que puede manipular el incremento o decremento de velocidad*/
public void mod_velocidad(int vel) 
{
 this.velocidad = this.velocidad + vel;
}

public void mod_bateria(int bat)
{
 this.bateria =this.bateria + bat;
}

//Metodo para manipular el encendido o apagado
public void set_motor(boolean estado)  
{
 this.motor = estado;
}

//Cambiar el valor de la velocidad de la moto
public void set_velocidad(int velocid) 
{
 this.velocidad = velocid;
}


}

Clase Main

import java.util.Scanner;

public class Main {

 
 public static void main(String[] args)
 {
  int op = 1;
  Scanner entra = new Scanner(System.in);
  
  moto Moto = new moto ("R2RG9", false, 0, 200); 
  
  while (op != 5 )
  {
  
  System.out.println("Placa:" + Moto.ret_placa());
  System.out.printf("Estado del motor:");
  if (Moto.ret_motor() == true)
  System.out.println("Prendido");
  else
     System.out.println("Apagado");
  System.out.println("Velocidad actual:" + Moto.ret_velocidad()+ " Km/h");
  System.out.println("Bateria:" + Moto.ret_bateria());
  System.out.println("");
  System.out.println("Seleccione:");
  System.out.println("1.Prender Moto");
  System.out.println("2.Apagar Moto");
  System.out.println("3.Acelerar");
  System.out.println("4.Frenar");
  System.out.println("");
  op = entra.nextInt();
  
  switch (op)
  {
  case 1:
   if (Moto.ret_bateria() > 0 )
   {
    
   if (Moto.ret_motor() == false)
   {
   Moto.set_motor(true);
   Moto.mod_bateria(-50);
   }
   
   else
   {
    System.out.println("La moto ya esta prendida.");
   }
   
  }
  
  else 
  {
   System.out.println("La vida de la Bateria se ha terminado.");
  }
   break;
   
  case 2:
   if (Moto.ret_motor() == true )
   {
   Moto.set_velocidad(0);
   Moto.set_motor(false);
   }
   
   else
   {
    System.out.println("La moto ya esta apagada.");
   }
   break;
   
  case 3:
   
  if ( Moto.ret_motor() == true )
  {
   if (Moto.ret_velocidad() < 300 )
   {
   Moto.mod_velocidad(+20);
   }
   else
   {
    System.out.printf("La velocidad de la moto esta al maximo.\n\n");
   }
  }
  
  else {
   System.out.println("La moto esta apagada.");
  }
   break;
   
  case 4:
  
   if ( Moto.ret_motor() == true )
   {
    if (Moto.ret_velocidad() > 0 )
    {
    Moto.mod_velocidad(-20);
    }
    
   }
   
   else {
    System.out.println("La moto esta apagada.");
   }
   
   break;
   
  default:
   
   break;
   
  }
  
  System.out.println("------------------------");
  } 
  
 }
 
}

Definición del Proyecto & Clases y Metodos

**Entrega 1**

Mi proyecto que tengo pensado hacer es un Gestor de Contactos, en donde se pueden almacenar datos de personas. Hice un borrador mas o menos hasta donde tengo pensando llegar con mi proyecto, si en el transcurso de las semanas se me ocurren mas cosas las iré añadiendo. Aquí un ejemplo de como se vería mi programa.

Tiene algunas cosas que pienso cambiar, por ejemplo los datos del usuario, puede que agregue mas campos.

La opción Exportar la tengo pensada para exportar los datos a una base de datos externa, puede que sea SQL aunque aun no conozco mucho del tema, esa seria una cosa que ando pensando agregar. En la pantalla de usuario viene un cuadro que dice extra, ese botón tambien estoy pensando en ponerlo o no, serviría para añadir notas del contacto, o algún otro campo secundario. En donde dice tipo, en realidad quería poner categoría del contacto, si es familiar, amigo etc.. y en el cuadro que aparece , tengo pensado que ahí irá una fotografía de la persona, y también el posible tamaño que tendría la foto en pixeles (300x200). La barra purpura seria movible por si el usuario quiere ver mas contactos y los cuadritos verdes significa que es una barra desplegable o de scroll, para ver la lista completa. 

Algunas opciones como "buscar", "ordenar", "cambiar letra", irían en edición o en opciones. El programa también permite crear categorías de contactos , algo así como en el MSN para tener ordenados los contactos. Lo demás que no explico aquí es auto explicito. 

CLASES, MÉTODOS, ATRIBUTOS 

1. Clase Contacto (Pública) -> Maneja la información de los contactos

    (Privados)Atributos: Nombre, Categoría, Dirección, Teléfono, Cumpleaños, Imagen 

    (Públicos) Metodos: Añadir, Borrar, Mover, Borrar

2. Clase Categoría (Publica) -> Es la clase que maneja las categorías de contactos.

   (Privados) Atributos: nombre_categoria, icono, contacto

   (Publicos) Metodos: añadir categoría, borrar categoría, modificar categoría.

Otros métodos:

• archivo-nuevo: Permite crear un archivo.

• abrir-archivo: Abre un archivo.

• guarda-archivo: Guarda el archivo para ser leído posteriormente.

• buscar-contacto: Proporcionando una palabra busca en la base de datos y filtra los que tengan ese dato.

• cambiar-color: Cambia el color visual de los datos, el fondo u otra característica gráfica.

• ordenar: Ordena los contactos alfabéticamente de la A - Z.

Por ahora creo que son suficientes, en el caso de que se me ocurra alguna corrección o que se me pase algo , modificare esta entrada después.

Herramientas

**Entrega 1** - Entrada Corregida 

**Corrección

• Eliminé Emacs de las herramientas. Para trabajar con Java en Ubuntu utilicé el gedit el cual ya viene incluido en Ubuntu.
• Agregué los links de referencia que faltaban.

Hola a todos, este es mi primer post sobre las herramientas que estare utilizando para llevar acabo el proyecto, por ahora solo he considerado estas, aunque tambien creo que utilizaré algun programa para los diagramas UML en caso de usarlos (lo mas probable).

Aqui mis herramientas actuales:

• Ubuntu 10.04.3 
• Librerias para Java (Openjdk-6-jdk)
• getEdit (Editor de Texto incluido en ubuntu)

Ubuntu 10.04.3

La version de ubuntu 10.04.3 es la que usaré, actualmente esta la 11.04 pero al parecer como es beta, aun tiene algunas fallas, de hecho no la pude instalar en mi usb, mejor preferí descargar la 10.04 y me funciona muy bien.

Openjdk-6-jdk

Son las librerias para poder programar en Java. Mas abajo pondré como se instalan por si alguien tuvo problemas, ya que en algunos tutoriales aparece que se instala directamente con el comando "sudo apt-get install Openjdk-6-jdk". En mi caso no funcionó, tuve que actualizar el "apt-get" antes de descargarlo.

Gedit

El editor de texto para trabajar con Java (y con otros lenguajes). Ya viene incluido en Ubuntu.

Umbrello

Software para trabajar con diagramas UML.

Instalación

Instalando Java

Este minitutorial lo hice en el caso de que no puedas instalar Java directamente usando el comando sudo apt-get install openjdk-6-jdk.

Para instalar los programas anteriores estos fueron los pasos que realicé.

1. Actualizar "apt-get" (en el caso de ser necesario), ya que a mi no me dejaba instalar las librerias de java porque habian algunas librerias que faltaban y como recomendacion, la consola me mostro el mensaje que intentara actualizar usando el comando

sudo apt-get update 

Si les pregunta algo le ponen una S, para confirmar. Ya despues de actualizar el "apt-get" podemos instalar las librerias de Java, para eso escribimos el siguiente

comando en la consola:

sudo apt-get install openjdk-6-jdk

Le ponemos la S y al final se verá algo como esto:

Ahora ya podemos compilar archivos java.

 Instalando Umbrello

Para poder Instalar umbrello, primero abrimos la consola y después tecleamos el siguiente comando:

sudo apt-get install umbrello

Con este comando, se empezará a instalar umbrello, con el cual podremos trabajar los diagramas UML. Cuando lo instalemos veremos una pantalla similar a la siguiente:

Referencias:

http://fernando-webblog.blogspot.com/2008/05/umbrello-uml-modeller.html
http://www.slideshare.net/maxkalavera/taller-oop-presentacion
http://www.taringa.net/posts/linux/11556168/Como-instalar-Java-en-Ubuntu-y-Linux-MInt.html