sábado, 9 de enero de 2010
CODIGO FUENTE PARTE 2 persona.java
import java.io.Serializable;
public class Persona implements Serializable {
private String name;
private String tel;
private String dir;
public Persona(String name,String tel,String dir){
this.name=name;
this.tel=tel;
this.dir=dir;
}
public String getName() {
return name;
}
public String getTel() {
return tel;
}
public String getDir() {
return dir;
}
public void setName(String name) {
this.name = name;
}
public void setTel(String tel) {
this.tel = tel;
}
public void setDir(String dir) {
this.dir = dir;
}
}
Como podemos ver el uso de archivos es muy importante para poder implementar y desarrollar un codigo mas robusto y eficiente para almacenar datos, e inclusive si se busca codigos ya mas estructurados, el uso de BSD es mas importante, ya que con ello se podra manejar de mejor manera el almacenamiento de datos,
Saludos...
Nomina.java Parte 2
En esta parte del codigo se encuentran las funciones que se hacen llamadas segun sea ingresado la opcion desde teclado, en el menu
principal.
En cada linea siguiente del codigo se hace una referencia corta del significado del codigo implementado.
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;
import javax.swing.JOptionPane;
public class nomina {
public ArrayListp;
public Scanner key1;
public nomina(){
p=new ArrayList();
}
public void addPersona(Persona o){
p.add(o);
}
// Metodo para la carga de datos desde un archivo en el dico duro
//throws IOException
public void load() throws IOException {
try {
//metodo que prepara el archivo para la lectura
FileReader file_in=new FileReader("lista.txt");
//Scanner es el encargado de leerlo y pasarlo a un tipo de dato Persona
Scanner key=new Scanner(file_in);
for(;;){
String cad=key1.nextLine();
String[] aux=cad.split("-");
Persona p=new Persona(aux[0],aux[1],aux[2]);
addPersona(p);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void save() throws IOException{
try {
//creacion de un archivo
File a=new File("lista.txt");
a.delete();
a.createNewFile();
//FileWriter es una funcion que permite la escritura en el archivo lista.txt
//False=sobrescritura de los datos almacenados
FileWriter file_write=new FileWriter("lista.txt",false);
//manda los bytes a un buffer para ser puestos en el archivo
PrintWriter pw=new PrintWriter(file_write);
for(Persona m:p){
String cad=m.getName()+"-"+m.getTel()+"-"+m.getDir();
pw.println(cad);
JOptionPane.showMessageDialog(null,"Guardado con exito! ...");
}
file_write.flush();//garantiza que todo se escriba en el archivo
file_write.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void imprimir(){
for(Persona m:p){
JOptionPane.showMessageDialog(null, m.getName()+" "+m.getTel()+" "+m.getDir());
}
}
}
principal.
En cada linea siguiente del codigo se hace una referencia corta del significado del codigo implementado.
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;
import javax.swing.JOptionPane;
public class nomina {
public ArrayList
public Scanner key1;
public nomina(){
p=new ArrayList
}
public void addPersona(Persona o){
p.add(o);
}
// Metodo para la carga de datos desde un archivo en el dico duro
//throws IOException
public void load() throws IOException {
try {
//metodo que prepara el archivo para la lectura
FileReader file_in=new FileReader("lista.txt");
//Scanner es el encargado de leerlo y pasarlo a un tipo de dato Persona
Scanner key=new Scanner(file_in);
for(;;){
String cad=key1.nextLine();
String[] aux=cad.split("-");
Persona p=new Persona(aux[0],aux[1],aux[2]);
addPersona(p);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void save() throws IOException{
try {
//creacion de un archivo
File a=new File("lista.txt");
a.delete();
a.createNewFile();
//FileWriter es una funcion que permite la escritura en el archivo lista.txt
//False=sobrescritura de los datos almacenados
FileWriter file_write=new FileWriter("lista.txt",false);
//manda los bytes a un buffer para ser puestos en el archivo
PrintWriter pw=new PrintWriter(file_write);
for(Persona m:p){
String cad=m.getName()+"-"+m.getTel()+"-"+m.getDir();
pw.println(cad);
JOptionPane.showMessageDialog(null,"Guardado con exito! ...");
}
file_write.flush();//garantiza que todo se escriba en el archivo
file_write.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void imprimir(){
for(Persona m:p){
JOptionPane.showMessageDialog(null, m.getName()+" "+m.getTel()+" "+m.getDir());
}
}
}
CODIGO FUENTE PARTE 1 aplicacion.java
Este codigo se compone de tres clases, la clase nomina y la clase empleado.
Pues bien como se ha mencionado en entradas anteriores, es necesario saber implementar un codigo que almacene datos, claro cuando sea necesario no todo sera necesario, como vimos el video anterior, podemos apreciar de mejor manera como se va almacenando datos segun la entrada que se escriba desde teclado. En este primer codigo solo realiza la validacion de entrada de teclado para el menu principal, con la ayuda de la libreria java.util.regex.* que nos ayuda a poder validar los datos que se ingresan por teclado y mediante la ayuda de la sentencia if comparar dichos datos y si son erroneos mostrar un mensaje de advertencia (ver grafico 1). Este codigo tambien se compone de la sentencia swich que nos ayuda a poder seleccionar la opcion ingresada por teclado, pues bien en cada uno de los casos se hace llamada a funciones especificas para realizar operaciones mostradas en el menu, como ingreso de datos, guardar la lista, mostrar en pantalla, etc. (ver grafico 2)
import javax.swing.JOptionPane;
import java.io.IOException;
import java.util.Scanner;
import java.util.regex.*;
public class Aplicacion
{
public static void main(String[] args) throws IOException
{
nomina ag=new nomina();
String entrada;
for(;;)
{
entrada=JOptionPane.showInputDialog("1. Usuario nuevo\n2. Cargar la lista\n3. Mostrar listado\n4. Guardar la lista\n 5. Salir\n");
Pattern q=Pattern.compile("[0-9]");
Matcher m=q.matcher(entrada);
if ((entrada != null) && (entrada.length() > 0) && (m.find()))
grafico 1
{
int num = Integer.parseInt(entrada);
{ grafico 2
case 1:
{
El uso de String cad = .... nos ayuda a almacenar las variables ingresadas por teclado, y mediante []aux=cad.split("-"), permitir que se escriba la expresion - para poder separar dichos datos, Ya ingresado estos datos se realiza el cambio a un tipo de dato Persona p, con ello hacemos llamado a dicha funcion y enviamos los datos para la verificacion.
String cad = JOptionPane.showInputDialog("Ingrese: nombre de usuario - telefono - direccion ");
String []aux=cad.split("-");
Persona p=new Persona(aux[0],aux[1],aux[2]);
ag.addPersona(p);
ag.save();
}break;
case 2:
{
ag.load();
ag.imprimir();
}break;
case 3:
{
ag.imprimir();
}break;
case 4:
{
ag.save();
}break;
case 5:
{
JOptionPane.showMessageDialog(null,"Gracias por usar esta aplicacion");
}return;
default:
{
JOptionPane.showMessageDialog(null,"elija una opcion");
}
}
}
else
JOptionPane.showMessageDialog(null,"Las opciones no contienen letras ni puede dejar vacio la seleccion..\n\n Elija por favor una opcion...."," ERROR",JOptionPane.WARNING_MESSAGE); }
}
}
En cada caso solo se hace llamado a la funcion necesaria para ejecutar parte del codigo segun la necesidad del usuario ingresada desde el teclado...
Pues bien como se ha mencionado en entradas anteriores, es necesario saber implementar un codigo que almacene datos, claro cuando sea necesario no todo sera necesario, como vimos el video anterior, podemos apreciar de mejor manera como se va almacenando datos segun la entrada que se escriba desde teclado. En este primer codigo solo realiza la validacion de entrada de teclado para el menu principal, con la ayuda de la libreria java.util.regex.* que nos ayuda a poder validar los datos que se ingresan por teclado y mediante la ayuda de la sentencia if comparar dichos datos y si son erroneos mostrar un mensaje de advertencia (ver grafico 1). Este codigo tambien se compone de la sentencia swich que nos ayuda a poder seleccionar la opcion ingresada por teclado, pues bien en cada uno de los casos se hace llamada a funciones especificas para realizar operaciones mostradas en el menu, como ingreso de datos, guardar la lista, mostrar en pantalla, etc. (ver grafico 2)
import javax.swing.JOptionPane;
import java.io.IOException;
import java.util.Scanner;
import java.util.regex.*;
public class Aplicacion
{
public static void main(String[] args) throws IOException
{
nomina ag=new nomina();
String entrada;
for(;;)
{
entrada=JOptionPane.showInputDialog("1. Usuario nuevo\n2. Cargar la lista\n3. Mostrar listado\n4. Guardar la lista\n 5. Salir\n");
Pattern q=Pattern.compile("[0-9]");
Matcher m=q.matcher(entrada);
if ((entrada != null) && (entrada.length() > 0) && (m.find()))
grafico 1
int num = Integer.parseInt(entrada);
switch(num)
case 1:
{
El uso de String cad = .... nos ayuda a almacenar las variables ingresadas por teclado, y mediante []aux=cad.split("-"), permitir que se escriba la expresion - para poder separar dichos datos, Ya ingresado estos datos se realiza el cambio a un tipo de dato Persona p, con ello hacemos llamado a dicha funcion y enviamos los datos para la verificacion.
String cad = JOptionPane.showInputDialog("Ingrese: nombre de usuario - telefono - direccion ");
String []aux=cad.split("-");
Persona p=new Persona(aux[0],aux[1],aux[2]);
ag.addPersona(p);
ag.save();
}break;
case 2:
{
ag.load();
ag.imprimir();
}break;
case 3:
{
ag.imprimir();
}break;
case 4:
{
ag.save();
}break;
case 5:
{
JOptionPane.showMessageDialog(null,"Gracias por usar esta aplicacion");
}return;
default:
{
JOptionPane.showMessageDialog(null,"elija una opcion");
}
}
}
else
JOptionPane.showMessageDialog(null,"Las opciones no contienen letras ni puede dejar vacio la seleccion..\n\n Elija por favor una opcion...."," ERROR",JOptionPane.WARNING_MESSAGE); }
}
}
En cada caso solo se hace llamado a la funcion necesaria para ejecutar parte del codigo segun la necesidad del usuario ingresada desde el teclado...
Video que muestra el uso de archivos
Como se menciono antes, esta vez toca el uso de archivos, para manejar datos y almacenarlos en un archivo, a continuacion se muestra una captura del programa ejecutado, mas adelante se subira el codigo y se explicara detalle a detalle dicho codigo...
martes, 5 de enero de 2010
CODIGO DE IMPLEMENTACION (3da parte) empleado.java
En esta tercera y ultima entrada del codigo de implementacion para una nomina de empleado sencilla. simplemente comentaremos las lineas que se encuentran en el codigo, por razones de que en las entradas anteriores se colocaron ya imagenes que pueden ayudar a entender de buena manera la implementacion del codigo, esta parte del codigo, no se imprime nada en cuadro de dialogos, mas bien donde se hace llamada a las funciones empleados.
veamos el codigo
class Empleado
{
//atributos
private String nombre;
private double sueldo;
private int id;
private static int idSiguiente = 1;
//Constructor
public Empleado (String n, double s )
{
nombre = n;
sueldo = s;
id = idSiguiente; //toma el proximo ID disponible
idSiguiente++; //incremente id
}
public Empleado ( ) { this("S/N", 0); }
public Empleado ( String n) { this(n, 0); }
public Empleado ( double s) { this("S/N", s); }
public String getNombre()
{
return nombre;
}
public double getSueldo()
{
return sueldo;
}
public int getId()
{
return id;
}
public static int getIdSiguiente()
{
return idSiguiente;
}
} //fin clase empleado
Como vemos es un codigo mas corto que los dos anteriores, como primer paso es crear la clase empleado. Para la siguientes lineas hacemos uso de funciones privadas que retornan un valor para que pueda ejecutarse el codigo completamente y sin errores. Otras funciones son publicas ya que es necesario que se las llame mediante otro codigo implementado, segun sea la necesidad. En esta seccion no hacemos uso de librerias ya que no necesitamos, validar o simplemente imprimir un cuadro de dialogo.
COMENTARIO FINAL
Este codigo implementado, podria desrrollarse de mejor manera, con mas opciones como son las de datos como numeros de telefono direccion, estado civil, nacionalidad, etc. Dado que la elaboracion de este tipo de codigos ya mas avanzados requiere dedicarle mucho mas tiempo, no ha sido posible implementar un codigo de tal magnitud, por lo que se a optado por un codigo, no tan sencillo, pero si para entender como poder realizar ingreso de datos, validaciones, etc.
Este codigo fue desarrollado e implementado por DAVID NUNEZ. basado en codigos fuente similares pero mas elaborados y en su totalidad mejor estructurados, para poder implementar dicha aplicacion, Acontinuacion se coloca los enlaces de ayuda.
http://www.chuidiang.com/chuwiki/index.php?title=JOptionPane_y_di%C3%A1logos_modales
http://grupos.emagister.com/debate/validacion_de_letras_y_espacios/6709-289716
http://www.programacion.com/java/articulo/expresionesreg/
http://mygnet.net/codigos/java/
CODIGOS FUENTE
http://mygnet.net/it/descargas/codigos/codigos_fuentes_java_y_tutor_java_con_3000_codigos_fuentes_muy_buenos.2777.zip
http://mygnet.net/it/descargas/codigos/sistema_de_nominas_usando_polimorfismo.2641.zip
Cualquier duda o sugerencia por favor háganlo saber.
Saludos cordiales estimados compañeros
veamos el codigo
class Empleado
{
//atributos
private String nombre;
private double sueldo;
private int id;
private static int idSiguiente = 1;
//Constructor
public Empleado (String n, double s )
{
nombre = n;
sueldo = s;
id = idSiguiente; //toma el proximo ID disponible
idSiguiente++; //incremente id
}
public Empleado ( ) { this("S/N", 0); }
public Empleado ( String n) { this(n, 0); }
public Empleado ( double s) { this("S/N", s); }
public String getNombre()
{
return nombre;
}
public double getSueldo()
{
return sueldo;
}
public int getId()
{
return id;
}
public static int getIdSiguiente()
{
return idSiguiente;
}
} //fin clase empleado
Como vemos es un codigo mas corto que los dos anteriores, como primer paso es crear la clase empleado. Para la siguientes lineas hacemos uso de funciones privadas que retornan un valor para que pueda ejecutarse el codigo completamente y sin errores. Otras funciones son publicas ya que es necesario que se las llame mediante otro codigo implementado, segun sea la necesidad. En esta seccion no hacemos uso de librerias ya que no necesitamos, validar o simplemente imprimir un cuadro de dialogo.
COMENTARIO FINAL
Este codigo implementado, podria desrrollarse de mejor manera, con mas opciones como son las de datos como numeros de telefono direccion, estado civil, nacionalidad, etc. Dado que la elaboracion de este tipo de codigos ya mas avanzados requiere dedicarle mucho mas tiempo, no ha sido posible implementar un codigo de tal magnitud, por lo que se a optado por un codigo, no tan sencillo, pero si para entender como poder realizar ingreso de datos, validaciones, etc.
Este codigo fue desarrollado e implementado por DAVID NUNEZ. basado en codigos fuente similares pero mas elaborados y en su totalidad mejor estructurados, para poder implementar dicha aplicacion, Acontinuacion se coloca los enlaces de ayuda.
http://www.chuidiang.com/chuwiki/index.php?title=JOptionPane_y_di%C3%A1logos_modales
http://grupos.emagister.com/debate/validacion_de_letras_y_espacios/6709-289716
http://www.programacion.com/java/articulo/expresionesreg/
http://mygnet.net/codigos/java/
CODIGOS FUENTE
http://mygnet.net/it/descargas/codigos/codigos_fuentes_java_y_tutor_java_con_3000_codigos_fuentes_muy_buenos.2777.zip
http://mygnet.net/it/descargas/codigos/sistema_de_nominas_usando_polimorfismo.2641.zip
Cualquier duda o sugerencia por favor háganlo saber.
Saludos cordiales estimados compañeros
lunes, 4 de enero de 2010
CODIGO DE IMPLEMENTACION (2da parte) nomina.java
Saludos nuevamente amigos, en esta ocacion continuaremos con la explicacion del codigo implementado para una nomina de trabajadores sencilla. La clase principal para esta parte es nomina.
Como vimos anteriormente en el uso de la sentencia switch se escogia 4, pues bien la primera opcion del caso 1 Ingreso de datos, podemos ver el codigo marcado de color azul, Al seleccionar la opcion 1 se ha el llamado a la funcion LeerDatos, con lo cual podemos ingresar los datos de nombre y sueldo.
El codigo implementado trabaja con la sentencia if y el uso de Pattern y Match, con esto logramos que los datos que se ingresen desde teclado, para el primer caso, sea solo nombre y no numeros, y para el segundo caso solo numeros y no letras, pues bien, en el caso de que no se ingrese lo pedido, se mostrara un mensaje de error, y realizando nuevamente la operacion para ingresar datos. Para ello se ha implementado la sentencia do while que permite realizar repetidas veces la misma operacion hasta que se satisfaga la condicion y pueda pasar a la siguiente linea que es el envio de datos n y s, donde n es la variable donde se almacena el nombre de usuario y es de tipo String, mientras que s ecd s la variable donde se almacena el valor del sueldo y es de tipo Double.
Para las opciones 2 y 3 de nuestro menu, en cada caso (2 y 3) se hace el llamado a la función muestra que permite imprimrir con ayuda del JOptionPane, los resultados del alamacenamiento de datos. (ver codigo de color naranja). En esta expresion se a hecho uso de la sentencia for que permite mostrar cada uno de los usuarios registrados y mostrar en un cuadro de dialogo uno por uno los usuarios y la cantidad de usuarios registrados. Esto es por el uso de JoptionPane.
Pero si trabajamos simplemente con System.println obtendriamos una mejor visualizacion de la nomina de empleados...
Es l oque se obtendria al elegir la opcion 3, cosa que con el JOptionPane no se pude mostrar completamente, para ello deberiamos usar Jframe. pero bueno, quizas mas adelante veamos una implementacion con dicha libreria.
Continuando con el codigo, la sentencia if nos ayuda a verificar si existen o no usuarios registrados, para cada caso realizara la accion correspondiente, siendo una de ellas en el caso de que no existan usuarios, mostrar un cuadro de dialogo que nos indica que no existen usuarios registrados.
En este codigo existen varias sentencias publicas, que son leidas desde otra expresion y llamadas a ejecutarse, mientras que cada funcion contiene expresiones privadas que solo dichas funciones pueden hacer uso de ellas. Como vemos hemos utilizado las mismas librerias y paquetes siendo muy importante tener el conocimiento de ellas.
import javax.swing.JOptionPane; //Libreria que sirve para utilizar JOptionPane import java.util.regex.*; // Libreria que permite usar Matcher y Pattern
//Una nomina esta compuesta de empleados(arreglo de)
public class nomina { //datos de la nomina private Empleado [] empleados; //la nomina "TIENE" empleados private int dim; // # de empleados
public nomina(int d) { empleados = new Empleado[d]; }
public nomina() { //constructor por default this(5); }
public void leerDatos(int limite) { String n,r ; double s; do { n=JOptionPane.showInputDialog("Ingresa nombre empleado["+(limite+1)+"]: "); Pattern p=Pattern.compile("[0-9]"); Matcher m=p.matcher(n); if((n != null) && (m.find())) { JOptionPane.showMessageDialog(null,"ERROR\n\n Elija por favor una opcion...."," ERROR",JOptionPane.WARNING_MESSAGE); } }while(n=="[a-zA-Z]"); do { s=Double.parseDouble(r=JOptionPane.showInputDialog("Ingrese el sueldo")); }while ((r == null)&&(r=="[a-zA-Z]") ); empleados[limite]= new Empleado(n, s); }
public void Muestra(int limite,boolean Nomina) { if(limite>0) { double DblNomina=0; for(int i=0;i
} //clase nomina
En nuestra tercera y ultima entrega del desarrollo del proyecto continuaremos con lo que es la clase empleado, que nos permitira realizar acciones correspondientes a almacenamiento de datos, llamado de funciones, entre otros.
Saludos.
Como vimos anteriormente en el uso de la sentencia switch se escogia 4, pues bien la primera opcion del caso 1 Ingreso de datos, podemos ver el codigo marcado de color azul, Al seleccionar la opcion 1 se ha el llamado a la funcion LeerDatos, con lo cual podemos ingresar los datos de nombre y sueldo.
El codigo implementado trabaja con la sentencia if y el uso de Pattern y Match, con esto logramos que los datos que se ingresen desde teclado, para el primer caso, sea solo nombre y no numeros, y para el segundo caso solo numeros y no letras, pues bien, en el caso de que no se ingrese lo pedido, se mostrara un mensaje de error, y realizando nuevamente la operacion para ingresar datos. Para ello se ha implementado la sentencia do while que permite realizar repetidas veces la misma operacion hasta que se satisfaga la condicion y pueda pasar a la siguiente linea que es el envio de datos n y s, donde n es la variable donde se almacena el nombre de usuario y es de tipo String, mientras que s ecd s la variable donde se almacena el valor del sueldo y es de tipo Double.
Para las opciones 2 y 3 de nuestro menu, en cada caso (2 y 3) se hace el llamado a la función muestra que permite imprimrir con ayuda del JOptionPane, los resultados del alamacenamiento de datos. (ver codigo de color naranja). En esta expresion se a hecho uso de la sentencia for que permite mostrar cada uno de los usuarios registrados y mostrar en un cuadro de dialogo uno por uno los usuarios y la cantidad de usuarios registrados. Esto es por el uso de JoptionPane.
Pero si trabajamos simplemente con System.println obtendriamos una mejor visualizacion de la nomina de empleados...
Continuando con el codigo, la sentencia if nos ayuda a verificar si existen o no usuarios registrados, para cada caso realizara la accion correspondiente, siendo una de ellas en el caso de que no existan usuarios, mostrar un cuadro de dialogo que nos indica que no existen usuarios registrados.
En este codigo existen varias sentencias publicas, que son leidas desde otra expresion y llamadas a ejecutarse, mientras que cada funcion contiene expresiones privadas que solo dichas funciones pueden hacer uso de ellas. Como vemos hemos utilizado las mismas librerias y paquetes siendo muy importante tener el conocimiento de ellas.
import javax.swing.JOptionPane; //Libreria que sirve para utilizar JOptionPane import java.util.regex.*; // Libreria que permite usar Matcher y Pattern
//Una nomina esta compuesta de empleados(arreglo de)
public class nomina { //datos de la nomina private Empleado [] empleados; //la nomina "TIENE" empleados private int dim; // # de empleados
public nomina(int d) { empleados = new Empleado[d]; }
public nomina() { //constructor por default this(5); }
public void leerDatos(int limite) { String n,r ; double s; do { n=JOptionPane.showInputDialog("Ingresa nombre empleado["+(limite+1)+"]: "); Pattern p=Pattern.compile("[0-9]"); Matcher m=p.matcher(n); if((n != null) && (m.find())) { JOptionPane.showMessageDialog(null,"ERROR\n\n Elija por favor una opcion...."," ERROR",JOptionPane.WARNING_MESSAGE); } }while(n=="[a-zA-Z]"); do { s=Double.parseDouble(r=JOptionPane.showInputDialog("Ingrese el sueldo")); }while ((r == null)&&(r=="[a-zA-Z]") ); empleados[limite]= new Empleado(n, s); }
public void Muestra(int limite,boolean Nomina) { if(limite>0) { double DblNomina=0; for(int i=0;i
} //clase nomina
En nuestra tercera y ultima entrega del desarrollo del proyecto continuaremos con lo que es la clase empleado, que nos permitira realizar acciones correspondientes a almacenamiento de datos, llamado de funciones, entre otros.
Saludos.
LInks interesantes
Les dejo algunos links bastante interesantes, para entender mas sobre el uso del JOptionPane, ademas el uso de expresiones regulares y validaciones.
JOptionPane
http://www.chuidiang.com/chuwiki/index.php?title=JOptionPane_y_di%C3%A1logos_modales
EXPRESIONES REGULARES
http://www.programacion.com/java/articulo/expresionesreg/
JOptionPane
http://www.chuidiang.com/chuwiki/index.php?title=JOptionPane_y_di%C3%A1logos_modales
EXPRESIONES REGULARES
http://www.programacion.com/java/articulo/expresionesreg/
domingo, 3 de enero de 2010
CODIGO DE IMPLEMENTACION (1ra parte) principal.java
Es importante tener conocimiento acerca de herencia, polimorfismo, uso de sentencias como son for, if else, do while, tambien es necesario conocer sobre expresiones regulare, validacion, entre otras cosas. Pues bien dado la primera parte del codigo, se procedera a dar la explicacion de las lineas que componen dicho codigo, dando ademas conceptos basicos para ententer dicho codigo.
Pues bien en las dos primeras lineas hacemos uso de las librerias mostradas en el codigo, para hacer uso de los cuadros de dialogo, y la segunda para poder usar expresiones regulares y con ello tambien validar dichas expresiones. EJEMPLOS
import javax.swing.JOptionPane;
import java.util.regex.*;
------------------------------------------------------------------------------------------------------------------------------------------
Acontinuacion simplemente creamos la clase principal y con ello la implementacion del codigo.
//cliente de prueba para la clase nomina
class principal
{
public static void main(String[] args)
{
int num, IntCont=0;
String entrada;
nomina nom = new nomina(50);
for(;;){ //permite realizar un menu infinito.
// La siguiente linea simplemente nos muestra un cuadro de dialogo con las opciones que necesitamos
entrada=JOptionPane.showInputDialog("\n Realizado por grupo 13 \n\n***********************\nDavid Nunez\n***********************\n\n1.- Ingreso de Empleado\n2.- Mostrar Listado\n3.- Mostrar Nomina Completa\n4.- Eliminar Ultimo Registro\n5.- Salir\n\nOpcion: ");
------------------------------------------------------------------------------------------------------------------------------------------
Simplemente con el uso de Pattern y Matcher realizamos la validacion para verificar que los datos de teclado sean numeros y no letras. y con el uso de la sentencia if nos ayudamos a verificar dichos valores ademas de verificar que se teclee alguna opcion, para cualquier caso se mostrara un mensaje de error como se muestra en la siguiente figura. Si el valor se encuentra correcto, la sentencia if permite saltar a la siguiente linea para seguir ejecutando el codigo.
la sentencia que nos permite mostrar este dialogo se encuentra al final del codigo, y es el uso de la sentencia else.
Pattern p=Pattern.compile("[0-9]");
Matcher m=p.matcher(entrada);
if ((entrada != null) && (entrada.length() > 0) && (m.find()))
------------------------------------------------------------------------------------------------------------------------------------------
En esta parte del codigo, viene lo que es la sentencia switch, que permite realizar un menu con opciones y que dada la opcion desde teclado, permita ejecutar alguna expresion o codigo en especial. Pues bien para nuestro caso tenemos 5 opciones, para seleccionar cada opcion se usa case (opcion):
y luego se puede implementar un codigo o llamar simplemente a una funcion para que se ejecute.
En el caso uno se llama a LeerDatos, esto nos permitira ingresar los datos por teclado, claro que por cada usuario que se ingrese sera necesario almacenar en un contador. Con esto nos ayudaremos a verificar si existen o no usuarios para los casos 2 y 3. En el caso de que no se haya inscrito ningun usuario y se selecciona la opcion 2 o tres se nos mostrara un mensaje de advertencia y se nos pedira nuevamente seleccionar la opcion primera.
{
num = Integer.parseInt(entrada);
switch(num)
{
------------------------------------------------------------------------------------------------------------------------------------------
En el caso 1 que es la opcion de ingresar datos se hace el llamado a nomina y se nos pedira dos datos, el nombre del usuario y el sueldo que ganara. Ya ingresado los datos correspondientes, se volvera al menu principal y realizar cualquier consulta, o eliminar el usuario
case 1:
{
nom.leerDatos(IntCont++);
}break;
En el caso dos ya ingresado los datos podemos llamar a la funcion empleado y constatar que esta ingresado el usario con el salario correspondiente, ademas podemos ver cuantos registros existen. Mas adelante veremos el codigo que permite realizar dichas acciones.
case 2:
{
nom.Muestra(IntCont,false);
}break;
------------------------------------------------------------------------------------------------------------------------------------------
Para el caso tres es similar al caso dos pero con la diferencia que al final se mostrar cual es el total que se debe pagar por salario de empleados.
case 3:
{
nom.Muestra(IntCont,true);
}break;
------------------------------------------------------------------------------------------------------------------------------------------
En la opcion 4 se nos permite borrar la ultima entrada ingresada, es decir, si se ingresa primero el usuario david y luego el usuario andres, el usuario a eliminarse sera andres. Claro que primero se nos muestra un cuadro de dialogo que permite elegir entre borrar y no hacerlo. Esto es con ayuda de JOptionPane.showConfirmDialog Con la sentencia if nos permitimos realizar la eliminacion del usuario en caso de que se haya seleccionado Ok, caso contrario el registro seguira intacto. veamos los ejermplos
case 4:
{
int confirmado = JOptionPane.showConfirmDialog(null ,"¿En verdad desea eliminar la ultima entrada?");
if (JOptionPane.OK_OPTION == confirmado)
{
IntCont--;
JOptionPane.showMessageDialog(null,"\nRegistro Eliminado!...\n");
}
else
JOptionPane.showMessageDialog(null,"\n No se elimino el registro...");
}break;
Al volver a seleccionar las opciones 2 y 3 simplemente aparecera los usuarios que quedaron registrados, para nuestro ejemplo como se inscribio 2 y se elimino el ultimo se nos mostraria nuevamente en el cuadro de dialogo
------------------------------------------------------------------------------------------------------------------------------------------
En esta opcion simplemente se muestra un cuadro de dialogo de agradecimiento.
case 5:
{
JOptionPane.showMessageDialog(null,"\nGracias por utilizar este programa....\n");
System.exit(0);
}break;
------------------------------------------------------------------------------------------------------------------------------------------
en la opcion default simplemente nos permite mostrar un cuadro de dialogo pidiendo que se seleccione una opcion entre la 1 y 5. Este mensaje de seleccion erronea se mostrara siempre y cuando las opciones ingresadas por teclado no esten entre 1 y 5.
default:
{
JOptionPane.showMessageDialog(null,"Seleccion erronea\n\n\nElija nuevamente una opcion del 1 al 5...", "META BIEN EL DEDO CARAMBA", )OptionPane.PLAIN_MESSAGE);
}
}
}
------------------------------------------------------------------------------------------------------------------------------------------
else
JOptionPane.showMessageDialog(null,"Las opciones no contienen letras ni puede dejar vacio la seleccion..\n\n Elija por favor una opcion...."," ERROR",JOptionPane.WARNING_MESSAGE);
}
}
}
el uso de else nos permite mostrar el cuadro de dialogo de error cuando los datos ingresados por teclado para seleccionar una opcion, sean numeros o no se ingrese nada y se presione seguido enter.
En la proxima entrada seguire comentando la segunda parte del proyecto donde veremos en detalle cada una de las opciones seleccionadas desde menu. Por lo pronto me despido, deseandoles exitos enlas funciones que realicen...
Saludos y no se olviden de comentar estas entradas :):):)...
Pues bien en las dos primeras lineas hacemos uso de las librerias mostradas en el codigo, para hacer uso de los cuadros de dialogo, y la segunda para poder usar expresiones regulares y con ello tambien validar dichas expresiones. EJEMPLOS
import javax.swing.JOptionPane;
import java.util.regex.*;
------------------------------------------------------------------------------------------------------------------------------------------
Acontinuacion simplemente creamos la clase principal y con ello la implementacion del codigo.
//cliente de prueba para la clase nomina
class principal
{
public static void main(String[] args)
{
int num, IntCont=0;
String entrada;
nomina nom = new nomina(50);
for(;;){ //permite realizar un menu infinito.
// La siguiente linea simplemente nos muestra un cuadro de dialogo con las opciones que necesitamos
entrada=JOptionPane.showInputDialog("\n Realizado por grupo 13 \n\n***********************\nDavid Nunez\n***********************\n\n1.- Ingreso de Empleado\n2.- Mostrar Listado\n3.- Mostrar Nomina Completa\n4.- Eliminar Ultimo Registro\n5.- Salir\n\nOpcion: ");
------------------------------------------------------------------------------------------------------------------------------------------
Simplemente con el uso de Pattern y Matcher realizamos la validacion para verificar que los datos de teclado sean numeros y no letras. y con el uso de la sentencia if nos ayudamos a verificar dichos valores ademas de verificar que se teclee alguna opcion, para cualquier caso se mostrara un mensaje de error como se muestra en la siguiente figura. Si el valor se encuentra correcto, la sentencia if permite saltar a la siguiente linea para seguir ejecutando el codigo.
la sentencia que nos permite mostrar este dialogo se encuentra al final del codigo, y es el uso de la sentencia else.
Pattern p=Pattern.compile("[0-9]");
Matcher m=p.matcher(entrada);
if ((entrada != null) && (entrada.length() > 0) && (m.find()))
------------------------------------------------------------------------------------------------------------------------------------------
En esta parte del codigo, viene lo que es la sentencia switch, que permite realizar un menu con opciones y que dada la opcion desde teclado, permita ejecutar alguna expresion o codigo en especial. Pues bien para nuestro caso tenemos 5 opciones, para seleccionar cada opcion se usa case (opcion):
y luego se puede implementar un codigo o llamar simplemente a una funcion para que se ejecute.
En el caso uno se llama a LeerDatos, esto nos permitira ingresar los datos por teclado, claro que por cada usuario que se ingrese sera necesario almacenar en un contador. Con esto nos ayudaremos a verificar si existen o no usuarios para los casos 2 y 3. En el caso de que no se haya inscrito ningun usuario y se selecciona la opcion 2 o tres se nos mostrara un mensaje de advertencia y se nos pedira nuevamente seleccionar la opcion primera.
{
num = Integer.parseInt(entrada);
switch(num)
{
------------------------------------------------------------------------------------------------------------------------------------------
En el caso 1 que es la opcion de ingresar datos se hace el llamado a nomina y se nos pedira dos datos, el nombre del usuario y el sueldo que ganara. Ya ingresado los datos correspondientes, se volvera al menu principal y realizar cualquier consulta, o eliminar el usuario
case 1:
{
nom.leerDatos(IntCont++);
}break;
------------------------------------------------------------------------------------------------------------------------------------------
case 2:
{
nom.Muestra(IntCont,false);
}break;
Para el caso tres es similar al caso dos pero con la diferencia que al final se mostrar cual es el total que se debe pagar por salario de empleados.
case 3:
{
nom.Muestra(IntCont,true);
}break;
En la opcion 4 se nos permite borrar la ultima entrada ingresada, es decir, si se ingresa primero el usuario david y luego el usuario andres, el usuario a eliminarse sera andres. Claro que primero se nos muestra un cuadro de dialogo que permite elegir entre borrar y no hacerlo. Esto es con ayuda de JOptionPane.showConfirmDialog Con la sentencia if nos permitimos realizar la eliminacion del usuario en caso de que se haya seleccionado Ok, caso contrario el registro seguira intacto. veamos los ejermplos
case 4:
{
int confirmado = JOptionPane.showConfirmDialog(null ,"¿En verdad desea eliminar la ultima entrada?");
if (JOptionPane.OK_OPTION == confirmado)
{
IntCont--;
JOptionPane.showMessageDialog(null,"\nRegistro Eliminado!...\n");
}
else
JOptionPane.showMessageDialog(null,"\n No se elimino el registro...");
}break;
y en el caso que se hayan borrado completamente los usarios nuevamente se nos mostrara el cuadro de dialogo de no existen usuarios.
En esta opcion simplemente se muestra un cuadro de dialogo de agradecimiento.
case 5:
{
JOptionPane.showMessageDialog(null,"\nGracias por utilizar este programa....\n");
System.exit(0);
}break;
------------------------------------------------------------------------------------------------------------------------------------------
en la opcion default simplemente nos permite mostrar un cuadro de dialogo pidiendo que se seleccione una opcion entre la 1 y 5. Este mensaje de seleccion erronea se mostrara siempre y cuando las opciones ingresadas por teclado no esten entre 1 y 5.
default:
{
JOptionPane.showMessageDialog(null,"Seleccion erronea\n\n\nElija nuevamente una opcion del 1 al 5...", "META BIEN EL DEDO CARAMBA", )OptionPane.PLAIN_MESSAGE);
}
}
}
------------------------------------------------------------------------------------------------------------------------------------------
else
JOptionPane.showMessageDialog(null,"Las opciones no contienen letras ni puede dejar vacio la seleccion..\n\n Elija por favor una opcion...."," ERROR",JOptionPane.WARNING_MESSAGE);
}
}
}
el uso de else nos permite mostrar el cuadro de dialogo de error cuando los datos ingresados por teclado para seleccionar una opcion, sean numeros o no se ingrese nada y se presione seguido enter.
En la proxima entrada seguire comentando la segunda parte del proyecto donde veremos en detalle cada una de las opciones seleccionadas desde menu. Por lo pronto me despido, deseandoles exitos enlas funciones que realicen...
Saludos y no se olviden de comentar estas entradas :):):)...
SIMPLE NOMINA DE EMPLEADOS
Si bien es cierto para poder contar con una nomina completa y bien estructurada, con la ayuda de java, es necesario implementar tal código con una base de datos estructurada para dicho propósito. Como ya se menciono en entradas anteriores no usaremos una base de datos para implementar dicho código, mas bien solo usaremos variables en las que se almacena los datos ingresados por teclado, que por cierto al momento de terminar la aplicación no quedara rastro de tales datos.
VIDEO DE IMPLEMENTACION DEL CODIGO
A continuacion se presenta el video en el cual se muestra la ejecucion del programa, este es ya una maqueta casi terminada de lo que se ha buscado. Si se agregan mas codigo al proyecto, se subira otro video con tal implementacion. Por el momento se presenta este diseno y acontinuacion dare una explicacion del codigo implementado.
VIDEO DE IMPLEMENTACION DEL CODIGO
A continuacion se presenta el video en el cual se muestra la ejecucion del programa, este es ya una maqueta casi terminada de lo que se ha buscado. Si se agregan mas codigo al proyecto, se subira otro video con tal implementacion. Por el momento se presenta este diseno y acontinuacion dare una explicacion del codigo implementado.
Diagramas UML...
DIAGRAMAS UML
Puesto que es necesario saber que necesitamos para realizar una implementacion correcta del codigo fuente, acontinuacion se presenta el diagrama UML. que servira de guia para implementar las necesidades en el codigo fuente.
Pues bien, lo que se busca es crear un codigo que permita almacenar datos de empleados para una empresa x. Claro en este caso no usaremos una base de datos para poder realizar tal accion, solo usaremos lo que son almacenamiento en variables. Lo que necesitaremos es que se pida el nombre del empleado y cuanto sera el sueldo que tendra dicho empleado. Queremos que en un menu de opciones nos permita elejir ver cada uno de los empleados individualmente y en conjunto, y ademas ver cuanto sera los gastos totales de pagos a empleados.
Para realizar tal evento, necesitamos crear un menu principal, que permita el ingreso de datos del empleado y el sueldo que se pagara.
En la siguiente entrada se subira el codigo y se ira explicando cada parte de dicho codigo para poder entender mejor el uso de expresiones regulares, validaciones almacenamiento de variables, etc.
sábado, 2 de enero de 2010
Comentario de introduccion al proyecto
Hola amigos...Bueno aquí de unas largas vacaciones de navidad y fin de año, por fin hoy comenzare con la descripción, análisis y ejecución del proyecto final de programación orientada a objetos, que por cierto aun no les he dicho de que se trata. Bueno el proyecto que se va a desarrollar a cargo del grupo 13 progpoo.blogspot.com, es el uso de java para almacenar una nomina de trabajadores en lo que incluye nombre y sueldos, bueno es una aplicación un poco sencilla, pero se ira implementando opciones en las que el usuario que manipule la nomina, pueda realizar cambios y verificar cada empleado de una empresa x. Para poder tener un comprensión muy buena, me ayudare de captura de pantallas y grabaciones de mi escritorio. Con la ayuda de aplicaciones como son las de gtk-MyrecordDestok y el propio Snapshot de Ubuntu. Que por cierto ya no me hace falta windows...:):):).
En la siguiente entrada les comentare ya mas detalladamente la ejecucion del proyecto..
En la siguiente entrada les comentare ya mas detalladamente la ejecucion del proyecto..
Suscribirse a:
Entradas (Atom)