Práctica Programación. Clase que hace casi todo el trabajo.

package galia_kalchevska; import java.io.*; import java.util.*; /** * Clase que hace casi todo el trabajo. He intentado flexibilizarla lo máximo * posible. Casi nunca sale como quieres a la primera. * * @author GALIA * @version 9.0 */ public class Menu extends ArrayList<Object> implements Factura { /* Atributos privados */ private static Scanner sc; static boolean existe; /* te obliga a generar la constante al extender de ArrayList */ private static final long serialVersionUID = 1L; public static void go() throws IOException { /* Atributos */ /* Un List de los futuros clientes, de tipo Object */ List<Object> lista_clientes = null; /* controla la existencia del archivo donde se guardaran los datos */ existe = true; /* controla el menu principal */ String opcion_menu = "1"; /* archivo donde se escribirán los datos */ String ruta = "clientes.dat"; /* entrada teclado */ sc = new Scanner(System.in); /* el bucle muestra el menu principal */ do { /* atributos de la clase Cliente */ String nombre_empresa = null; String responsable_empresa = null; String numero_COITT = null; String direccion = null; String cif = null; String cuenta_corriente = null; /* tipo es enumerado */ TipoDeCliente tipo = null; /* almacenará los futuros cargos */ float cantidad_debe = 0f; /* método privado que muestra el menu */ opcion_menu = mostrar_menu(); /* opcion_menu controla las opciones del switch */ switch (opcion_menu) { /* Método que añade los clientes */ case "1": añadir_clientes(ruta, nombre_empresa, responsable_empresa, numero_COITT, direccion, cif, cuenta_corriente, tipo, cantidad_debe); break; /* visualiza los datos del archivo binario */ case "2": generar_informe(ruta); break; /* busca un objeto Cliente */ case "3": buscar_cliente(ruta); break; /* borra un objeto identificado por el CIF */ case "4": cif = borrar_cliente(ruta); break; case "5": /* borra el archivo binario */ borrar_fichero(ruta); break; /* * añade e escribe la cantidad que se ha de facturar en el ArrayList * de Cliente y en el archivo binario según el enunciado */ case "6": añadir_cantidad(ruta, tipo); break; case "7": File fichero_binario = new File("clientes.dat"); new File(fichero_binario, "clientes.txt"); /* se crea el ArrayList de objetos Cliente */ lista_clientes = new ArrayList<Object>(); lista_clientes = Lista.LeerFichero("clientes.dat"); /* se escribe contenido en el archivo */ Lista.EscribirFichero("clientes.txt", lista_clientes); break; case "8": obtener_contenido_ASCII("clientes.txt"); break; case "9": System.exit(0); break; default: System.out.println("Opción incorrecta"); break; } /* sale del switch menu */ } while (opcion_menu != "9"); } private static void añadir_cantidad(String ruta, TipoDeCliente tipo) throws NumberFormatException, IOException { /* Atributos del método */ /* El List con los objetos Cliente */ List<Object> lista_clientes; /* Objeto Cliente */ Cliente cliente; /* controla la existencia de un objeto Cliente en el ArrayList */ boolean encontrado; /* el cif del objeto, nos servirá de identificador */ String cif; /* Instanciamos el List como un ArrayList de tipo Object */ lista_clientes = new ArrayList<Object>(); /* Volcamos los datos del fichero binario al ArrayList */ lista_clientes = Lista.LeerFichero(ruta); /* * Variables para hacer los cálculos de las futuras cantidades * facturadas */ /* controla las opciones del tipo de trabajo facturado */ String opcion; /* buscamos el Cliente que queremos para añadir la cantidad */ System.out.println("Introduzca CIF de la empresa: "); cif = sc.next(); /* * Obtenemos el objeto, o sea, lo reconstruimos, para eso la clase * Cliente la hicimos Serializable */ float cantidadACobrar = 0; float totalFacturado = 0; int horas; for (int i = 0; i < lista_clientes.size(); i++) { cliente = (Cliente) lista_clientes.get(i); /* Si el CIF ingresado se corresponde con alguno del ArrayList */ if (cif.equals(cliente.getCif())) { /* objeto Cliente encontrado */ encontrado = true; /* opciones para las distintas modalidades de facturación */ System.out.println(".................\n" + " 1 Trabajo por horas\n" + " 2 Trabajo completo\n" + " 3 Salir\n" + "................."); sc = new Scanner(System.in); opcion = sc.nextLine(); /* * Opción es cobrar por horas, los campos finales están * inicializados en la interface Factura que implementa la clase * Lista */ if (Integer.parseInt(opcion) == 1) { /* parseo la opción, evito más comprobaciones */ System.out.println("Introduzca horas:"); sc = new Scanner(System.in); horas = sc.nextInt(); /* se añaden los cargos dependiendo del tipo de Cliente */ if (tipo == TipoDeCliente.NORMAL) { totalFacturado = precio_hora * horas; cantidadACobrar = cantidadACobrar + totalFacturado; System.out.println("Se ha añadido: " + cantidadACobrar + " €"); /* si es PREFERENTE */ } else { totalFacturado = precio_hora * horas; cantidadACobrar = cantidadACobrar + (totalFacturado - (totalFacturado * descuento / 100)); System.out.println("Se ha añadido: " + cantidadACobrar + " €"); } } /* más de lo mismo */ if (Integer.parseInt(opcion) == 2) { if (tipo == TipoDeCliente.NORMAL) { cantidadACobrar = cantidadACobrar + trabajo_fijo; } else { cantidadACobrar = cantidadACobrar + (trabajo_fijo - (trabajo_fijo * descuento / 100)); } System.out.println("Se ha añadido: " + cantidadACobrar + " €"); } /* Salimos con 3 */ if (Integer.parseInt(opcion) == 3) { break; } /* * en caso de que el CIF no existe en la base de datos, o sea el * fichero binario */ if (encontrado == false) { System.out.println("CIF: " + cif + " No encontrado\n"); } /* Añadimos la cantidad al cliente */ cliente.cantidad_debe = cantidadACobrar + cliente.cantidad_debe; /* escribimos en el fichero binario */ Lista.EscribirFichero(ruta, lista_clientes); } } } private static void borrar_fichero(String ruta) { /* controla si queremos borrar el fichero */ String respuesta; System.out.println("Borrar el fichero de los clientes s/n"); respuesta = sc.next(); /* Se borra tecleando s/S */ if (respuesta.equals("s") || respuesta.equals("S")) { /* usamos la clase File para poder hacer el borrado */ File archivo = new File(ruta); /* lo borra */ archivo.delete(); } else { /* para que me dejará una línea en blanco, por estética */ System.out.println(); } } private static boolean buscar_cliente(String ruta) throws IOException { /* las mismas variables, las he explicado arriba */ List<Object> lista_clientes; Cliente cliente; boolean encontrado; String cif; lista_clientes = new ArrayList<Object>(); lista_clientes = Lista.LeerFichero(ruta); System.out.println("Introduzca CIF de la empresa: "); cif = sc.next(); encontrado = false; /* buscamos el Cliente */ for (int i = 0; i < lista_clientes.size(); i++) { cliente = (Cliente) lista_clientes.get(i); /* Si lo encontramos, lo visualizamos */ if (cif.equals(cliente.getCif())) { System.out.println(cliente.toString()); encontrado = true; break; } } /* en caso de no encontrarle */ if (encontrado == false) { System.out.println("CIF: " + cif + " No encontrado"); } return encontrado; } private static void añadir_clientes(String ruta, String nombre_empresa, String responsable_empresa, String numero_COITT, String direccion, String cif, String cuenta_corriente, TipoDeCliente tipo, float cantidad_debe) throws IOException { /* Variable */ List<Object> lista_clientes; /* se crea el ArrayList de objetos Cliente */ lista_clientes = new ArrayList<Object>(); /* * se comprueba si existe el fichero de los clientes, llamando al método * correspondiente. En caso de que no existe el fichero, se crea y en * caso de que existe, se añaden los datos al final para no borrar los * existentes */ lista_clientes = Lista.LeerFichero(ruta); pedir_datos_clientes(lista_clientes, nombre_empresa, responsable_empresa, numero_COITT, direccion, cif, cuenta_corriente, tipo, cantidad_debe); /* se escribe el objeto en el archivo */ Lista.EscribirFichero(ruta, lista_clientes); } /* * Básicamente , invocamos el método toString de la clase Cliente. Nos * imprime el contenido del ArrayList completo */ private static void generar_informe(String ruta) throws IOException { List<Object> lista_clientes; Cliente cliente; lista_clientes = new ArrayList<Object>(); lista_clientes = Lista.LeerFichero(ruta); for (int i = 0; i < lista_clientes.size(); i++) { cliente = (Cliente) lista_clientes.get(i); System.out.println(cliente.toString()); } } private static void pedir_datos_clientes(List<Object> lista_clientes, String nombre_empresa, String responsable_empresa, String numero_COITT, String direccion, String cif, String cuenta_corriente, TipoDeCliente tipo, float cantidad_debe) { /* controla si queremos añadir más clientes */ String respuesta; Cliente cliente; do { try { /* llamamos al método correspondiente */ cif = Validaciones.comprobar_CIF(); /* * no se validan los datos, sería lo suyo validarlos con una * expresión regular */ System.out.println("Introduzca Nombre Empresa:"); nombre_empresa = sc.nextLine(); System.out.println("Introduzca Responsable:"); responsable_empresa = sc.nextLine(); /* * para comprobar si COITT es entero, según las indicaciones de * Javier ha de serlo. */ boolean numero_COITT_aux = true; do { System.out.println("Introduzca número COITT:"); numero_COITT = sc.nextLine(); /* invocamos al método correspondiente */ numero_COITT_aux = Validaciones.esEntero(numero_COITT); /* se sale del bucle si el método retorna true */ } while (numero_COITT_aux == false); System.out.println("Introduzca dirección:"); direccion = sc.nextLine(); /* llamamos a los métodos privados */ cuenta_corriente = validar_IBAN(); tipo = establecer_tipo_cliente(); } catch (Exception e) { /* el mensaje que sale capturando una excepción */ System.out.println("Datos introducidos incorrectos"); } /* * instanciamos un nuevo objeto Cliente, invocando al constructor de * la clase */ cliente = new Cliente(cif, nombre_empresa, responsable_empresa, numero_COITT, direccion, cuenta_corriente, tipo, cantidad_debe); /* se añade el objeto al ArrayList */ lista_clientes.add(cliente); /* Si queremos, podemos seguir insertando objetos cliente */ System.out.println("Desea introducir nuevo cliente:s/n"); /* controla la salida del do-while */ respuesta = sc.next(); /* se sigue sólo en caso de que se introduzca S/s */ } while (respuesta.equals("s") || respuesta.equals("S")); } private static TipoDeCliente establecer_tipo_cliente() { /* para establecer el tipo de cliente */ TipoDeCliente tipo; System.out.println("Introduzca Tipo de la Empresa: P/N"); sc = new Scanner(System.in); /* * variable auxiliar, si igual a p/P, el cliente se establece como * PREFERENTE */ String tipoE = sc.nextLine(); if (tipoE.equalsIgnoreCase("P")) { tipo = TipoDeCliente.PREFERENTE; /* en caso contrario, es de tipo NORMAL */ } else { tipo = TipoDeCliente.NORMAL; } /* devuelve el tipo del Cliente */ return tipo; } private static String borrar_cliente(String ruta) throws IOException { /* más e lo mismo */ /* Variables */ String cif; List<Object> lista_clientes; Cliente cliente; /* Declaramos el List como un ArrayList */ lista_clientes = new ArrayList<Object>(); /* Volcamos el archivo */ lista_clientes = Lista.LeerFichero(ruta); System.out.println("Introduzca CIF de la empresa: "); cif = sc.next(); /* buscamos por CIF */ for (int i = 0; i < lista_clientes.size(); i++) { cliente = (Cliente) lista_clientes.get(i); /* recogemos la referencia del objeto */ if (cif.equals(cliente.getCif())) { /* borramos el objeto Cliente */ lista_clientes.remove(i); break; } } /* Escribimos los cambios en el archivo binario */ Lista.EscribirFichero(ruta, lista_clientes); return cif; } private static String validar_IBAN() { /* validamos IBAN */ String cuenta_corriente; /* controla si IBAN es válido */ boolean correcto; /* sales si el formato es correcto */ do { System.out .println("Introduzca Cuenta Corriente: [AA0000000000000000000000]\nSon dos letras y 22 dígitos"); cuenta_corriente = sc.nextLine(); /* invocamos el método correspondiente */ correcto = Validaciones.comprobar_IBAN(cuenta_corriente); } while (correcto == false); /* devuelve el valor IBAN correcto */ return cuenta_corriente; } private static String mostrar_menu() { /* la opción tecleada */ String opcion_menu; /* controla la salida del do-while */ boolean es_numero = true; do { sc = new Scanner(System.in); System.out.println("1. Añadir clientes"); System.out.println("2. Generar informe"); System.out.println("3. Buscar cliente"); System.out.println("4. Borrar cliente"); System.out.println("5. Borrar fichero"); System.out.println("6. Añadir cantidad"); System.out.println("7. Grabar fichero"); System.out.println("8. Recuperar fichero"); System.out.println("9. Salir\n"); opcion_menu = sc.nextLine(); /* validamos que la entrada por teclado es numérica */ es_numero = Validaciones.isNumeric(opcion_menu); /* se sale si el resultado se evalúa a true */ } while (es_numero == false); /* retorna la opción elegida */ return opcion_menu; } /* * No me hace el casting de todos los caracteres bien, he leído que se debe * que la JVM que uso no utiliza UTF 16 */ private static byte[] obtener_contenido_ASCII(String ruta) { /* array de bytes para almacenar el contenido */ byte contenido_archivo_texto[] = null; try { /* se crea un objeto de la clase File */ File archivo = new File(ruta); /* se crea un objeto de la clase FileInputStream */ FileInputStream input = new FileInputStream(archivo); /* * Se crea un array de bytes suficientemente grande para almacenar * el contenido del archivo. Se usa File.length() para determinar el * tamaño del archivo en bytes */ contenido_archivo_texto = new byte[(int) archivo.length()]; /* * Para leer el contenido del archivo en el array de bytes, usamos * int read(byte[] byteArray), método de la clase FileInputStream. */ input.read(contenido_archivo_texto); /* se crea un string del array de bytes */ String contenido_del_archivo = new String(contenido_archivo_texto); System.out.println("Contenido del fichero : "); System.out.println(contenido_del_archivo); /* cerramos el stream */ input.close(); return contenido_archivo_texto; } catch (Exception e) { System.out.println(e.getMessage() + e); } return contenido_archivo_texto; } }