Inforem final de los codigos implementados para programacion orientada a objetos de la Escuela Politecnica Nacional

1. INFORME Tema: *NOMINA DE EMPLEADOS SENCILLA *USO DE ARCHIVOS Objetivos: Adquirir un mayor desempeño en cuanto a manejo y uso de expresiones regulares, validaciones, etc. En general poder plasmas en un codigo fuente el conocimiento adquirido. Mostrar que el uso de aplicaciones java es muy variado. Introducción: En palabras simples pero muy efectivas, el uso de diagramas UML ayudan a tener una mejor visualización de los requerimientos del usuario, es decir ,es una simplificación grafica del código a implementarse, que permite comprender el sistema que se va a desarrollar, acorde a las necesidades del usuario, pues bien, es necesario saber cuáles son nuestros requerimientos para desarrollar el código fuente. Puesto que es necesario saber que necesitamos para realizar una implementación correcta del código fuente, a continuación se presenta el diagrama UML. Que servirá de guía para implementar las necesidades en el código fuente. Ahora, lo que se busca es crear un código que permita almacenar datos de empleados para una empresa x. Claro en este caso no usaremos una base de datos para poder realizar tal acción, solo usaremos lo que son almacenamiento en variables. En la segunda parte se implementara un código que use archivos. Para el primer caso lo que necesitaremos es que se pida el nombre del empleado y cuanto será el sueldo que tendrá dicho empleado. Queremos que en un menú de opciones nos permita elegir ver cada uno de los empleados individualmente y en conjunto, y además ver cuanto será los gastos totales de pagos a empleados. Para realizar tal evento, necesitamos crear un menú principal, que permita el ingreso de datos del empleado y el sueldo que se pagara. 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 o en su defecto el uso de archivos. Como ya se menciono anteriormente no usaremos una base de datos para implementar dicho código, ni archivos , más 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. Marco Teórico Herencia en java Java permite el empleo de la herencia, característica muy potente que permite definir una clase tomando como base a otra clase ya existente. Esto es una de las bases de la reutilización de código, en lugar de copiar y pegar. Polimorfismo en java Este hecho de que un objeto pertenezca a una clase, pero que pueda cumplir uno o más interfaces es muy similar al hecho de que una persona (un objeto) es hija (un interfaz), posiblemente tía (otro interfaz) o incluso abuela (otro interfaz). Con esto lo que se indica es que un interfaz sólo tiene interés para quien lo necesite usar, es decir, el interfaz tío sólo lo necesitan los objetos sobrinos, no un objeto de tipo policía. Esta característica de que varios objetos de distintas clases puedan recibir el mismo mensaje y ser capaces de responderlo, es conocida como polimorfismo NOTA: A lo largo del informe se irá describiendo conceptos como expresiones regulares, validaciones, sentencias, etc. Implementación del Código Fuente Es importante tener conocimiento acerca de herencia, polimorfismo, uso de sentencias como son for, if else, do while, también es necesario conocer sobre expresiones regulare, validación, entre otras cosas. Pues bien dado la primera parte del código, se procederá a dar la explicación de las líneas que componen dicho código, dando además conceptos básicos para entender dicho código. Pues bien en las dos primeras líneas hacemos uso de las librerías mostradas en el código, para hacer uso de los cuadros de dialogo, y la segunda para poder usar expresiones regulares y con ello también validar dichas expresiones. EJEMPLOS import javax.swing.JOptionPane; import java.util.regex.*; ------------------------------------------------------------------------------------------------------------------------------------------ A continuación simplemente creamos la clase principal y con ello la implementación del código. //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 línea simplemente nos muestra un cuadro de dialogo con las opciones que necesitamos entrada=JOptionPane.showInputDialog(
Realizado por grupo 13 ***********************David Núñez***********************1.- Ingreso de Empleado2.- Mostrar Listado3.- Mostrar Nomina Completa4.- Eliminar Ultimo Registro5.- SalirOpcion:
); ------------------------------------------------------------------------------------------------------------------------------------------ Simplemente con el uso de Pattern y Matcher realizamos la validacion para verificar que los datos de teclado sean números y no letras. Y con el uso de la sentencia if nos ayudamos a verificar dichos valores además de verificar que se teclee alguna opción, 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 línea para seguir ejecutando el código. La sentencia que nos permite mostrar este dialogo se encuentra al final del código, 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 código, viene lo que es la sentencia switch, que permite realizar un menú con opciones y que dada la opción desde teclado, permita ejecutar alguna expresión o código en especial. Pues bien para nuestro caso tenemos 5 opciones, para seleccionar cada opción se usa case (opción): y luego se puede implementar un código o llamar simplemente a una función para que se ejecute. En el caso uno se llama a LeerDatos, esto nos permitirá ingresar los datos por teclado, claro que por cada usuario que se ingrese será 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 ningún usuario y se selecciona la opción 2 o tres se nos mostrara un mensaje de advertencia y se nos pedirá nuevamente seleccionar la opción primera. { num = Integer.parseInt(entrada); switch(num) { ------------------------------------------------------------------------------------------------------------------------------------------ En el caso 1 que es la opción de ingresar datos se hace el llamado a nomina y se nos pedirá dos datos, el nombre del usuario y el sueldo que ganara. Ya ingresado los datos correspondientes, se volverá al menú 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,
Registro Eliminado!...
); } else JOptionPane.showMessageDialog(null,
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 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,
Gracias por utilizar este programa....
); 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 erroneaElija 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.. 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. CLASES NOMINA DE EMPLEADOS 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 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 { if (Nomina==true) DblNomina+=empleados[i].getSueldo(); JOptionPane.showMessageDialog(null,
Registro
+(i+1)+
de
+limite+
Nombre:
+empleados[i].getNombre()+
Sueldo:
+empleados[i].getSueldo()+
----
); } if (Nomina==true) JOptionPane.showMessageDialog(null,
Nomina total a Pagar:
+DblNomina+
); } else JOptionPane.showMessageDialog(null,
No Hay Registros Disponibles!...
); } } //clase nomina CLASE EMPLEADO Ahora 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. USO DE ARCHIVOS Como se menciono antes, esta vez toca el uso de archivos, para manejar datos y almacenarlos en un archivo, a continuación se muestra una captura del programa ejecutado, por lo que se deja el enlace del video para que se lo pueda visualizar http://www.youtube.com/watch?v=3MzQ_zUeA0M&feature=player_embedded CODIGO FUENTE. 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 nuevo2. Cargar la lista3. Mostrar listado4. Guardar la lista 5. Salir
);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) { grafico 2case 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
);}}}elseJOptionPane.showMessageDialog(null,
Las opciones no contienen letras ni puede dejar vacio la seleccion.. 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... Nomina.java En esta parte del codigo se encuentran las funciones que se hacen llamadas segun sea ingresado la opcion desde teclado, en el menuprincipal.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 IOExceptionpublic void load() throws IOException {try {//metodo que prepara el archivo para la lecturaFileReader file_in=new FileReader(
lista.txt
);//Scanner es el encargado de leerlo y pasarlo a un tipo de dato PersonaScanner 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 blocke.printStackTrace();}}public void save() throws IOException{try {//creacion de un archivoFile 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 almacenadosFileWriter file_write=new FileWriter(
lista.txt
,false);//manda los bytes a un buffer para ser puestos en el archivoPrintWriter 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 archivofile_write.close();} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}}public void imprimir(){for(Persona m:p){JOptionPane.showMessageDialog(null, m.getName()+
+m.getTel()+
+m.getDir());}}} 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. COMENTARIO FINAL Estos codigos implementados, podrían desarrollarse de mejor manera, con más opciones como son las de datos como números de teléfono dirección, estado civil, nacionalidad, etc. Dado que la elaboración de este tipo de códigos ya más avanzados requiere dedicarle mucho más tiempo, además de tener conocimientos mas avanzados en java como el uso de JFrame, para el uso de cuadros de dialogo y cuadros de ingreso de datos, no ha sido posible implementar un código de tal magnitud, por lo que se ha optado por dos código, no tan sencillos, pero si para entender como poder realizar ingreso de datos, validaciones, uso de archivos, etc. El código nomina de empleados fue desarrollado e implementado por DAVID NUNEZ. Basado en códigos fuente similares pero más elaborados y en su totalidad mejor estructurados, para poder implementar dicha aplicación, A continuación se coloca los enlaces de ayuda. El segundo código Manejo de archivos ya fue implementado, lo único que se modifico en dicho código, es la validación de datos y el uso de modo grafico, ya que este código no fue implementado con validación, y es ejecutado en modo texto. A continuación los enlaces a los códigos de ayuda y código fuente. 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.