Práctica de los conceptos vistos hasta el tema 67 del Curso Java desde Cero

[lobo]

Programa con 4 clases para afianzar el manejo de clases de un ArrayList y otros conceptos de la POO en Java.

Funciona a la perfección y creo que tiene un código limpio y una interface intuitiva y amigable. Lo publico por si puede ser útil a alguien. También serán bienvenidas las críticas constructivas.

DIAGRAMA DE CLASES:


CLASE QUE GESTIONA LA ENTRADA POR TECLADO:

Código: [Seleccionar]

import java.util.Scanner;

public class EntradaTec {
   
    String entradaTec; //Declaración de objeto String para guardar la cadena tecleada
       
    public EntradaTec(){ //Constructor
        entradaTec="";         
    }
 
    public String pedirEntrada(){       
        Scanner entradaEsc = new Scanner(System.in);
        entradaTec = entradaEsc.nextLine();             
        return entradaTec;
    }       
}
CLASE QUE GESTIONA EL ArrayList:

Código: [Seleccionar]

/* CLASE PARA LA CREACCIÓN Y GESTIÓN DE UNA LISTA (ArrayList)
 * Se utiliza SOBRECARGA (3 métodos con el mismo nombre pero distintos parámetros) para el método addNombre
 */

import java.util.ArrayList;
import java.util.Iterator;

public class Lista{
   
    private String nombre;//Atributo o campo para los elementos de la lista
    private ArrayList<String> lista = new ArrayList<String>(); //Creación de un objeto array para objetos tipo String
    private String entrada;//Declaración de variable tipo String para guardar ñas entradas por teclado

    public Lista (){//Constructor vacío (se puede omitir)
    }
   
    public void addNombre(){//Método tipo procedimiento (setter) para añadir secuencialmente datos al ArrayList lista
        EntradaTec entrada = new EntradaTec();
        do {
            nombre = entrada.pedirEntrada();
            lista.add(nombre);
        }   while(nombre.length() >0);
        lista.remove("");//Borra el último elemento de la lista que es la cadena vacía de cierre 
    }
   
    public void addNombre(int i){//Método setter para insertar un datos em la posición dada por el parámetro formal i
        EntradaTec entrada = new EntradaTec();       
        System.out.println("Nombre a insertar en la lista:"); 
        nombre = entrada.pedirEntrada();
        lista.add(i, nombre);       
    }
   
    public void addNombre(String nombre){//Método setter) para añadir un solo nombre al final de la lista
        lista.add(nombre);
    }
   
    public void listado1 (){//Método setter para mostrar en fila todos los elementos de la lista 
        int i = 0;
        while(i < lista.size()){           
            String elemento = lista.get(i);
            switch (i) {
                case 0:  System.out.print("Elementos de la lista (en fila): ");System.out.print(elemento); break;               
                default: System.out.print(", " + elemento); break;
            }
            i++;
        }
        System.out.println(".");
    }
       
    public void listado2 (){//Método setter para mostrar en columna todos los elementos de la lista
        System.out.println("Elementos de la lista (en columna):");
        System.out.println("");
        for(String nombre: lista){//Bucle FOR_EACH o EXTENDIDO
            System.out.println("          " + nombre);
            System.out.println("");           
        }
    }
   
    public int getSize(){//Método tipo función (getter) que devuelve el tamaño de la lista
        return lista.size();
    }
   
    public void borraNombre(int i){//Método setter que borra el i-ësimo elemento de la lista
        lista.remove(i);
        System.out.println("Se ha borrado el elemento " + i + "ª de la lista");
    }
   
    public void borraLista(){//Método setter que borra todos los elementos de la lista
        lista.clear();
        System.out.println("Se han borrado todos los elementos de la lista");
    }

   
    public String Buscar(String nombre){//Método getter que busca un elemento en la lista
        Iterator<String> it = lista.iterator(); //Creamos el objeto it de tipo Iterator con String
            String tmpAnalizando ="";
            boolean resultado=false;
                   
            while (it.hasNext() ) { //Utilizamos el método hasNext de los objetos tipo Iterator
                 tmpAnalizando = it.next(); //Utilizamos el método next de los objetos tipo Iterator
                 System.out.println ("Analizando elemento... " + tmpAnalizando);
                 if (tmpAnalizando.contains(nombre)) {
                     resultado = true;//resultado cambia a true si y solo si nombre está en la lista                                             
                 }
                 else { } //else vacío; no hay acciones a ejecutar.
            } //Cierre del while
           
            if (resultado == true){//Condicional IF-ELSE que define el valor de la variable tmpAnalizando
                 tmpAnalizando = "El nombre " + nombre + " está en la lista";}
            else {
                 tmpAnalizando = "El nombre " + nombre + " no está en la lista";}
                   
        return tmpAnalizando;
    }

}

CLASE PARA LA ELECCIÓN DE OPCIONES (MENÚ):

Código: [Seleccionar]

/* CLASE PARA EL MENÚ DE OPCIONES EN LA GESTIÓN DE UNA LISTA (ArrayList)
 * El "número" de opción se carga como String mediante el método pedirEntrada() de la clase Entrada Tec
 * Para poder utilizar el "número" (cadena) de opción n como variable de condición en un switch
 * se convierte éste a Integer mediante el método parseInt(n) de la clase Integer */
 
public class OptList{
     
     Lista obLista = new Lista();//Creación de una instancia (objeto) de la clase Lista     

     public void opList(){   
         
        System.out.println("**************************************************************");
        System.out.println("* Elija una acción:                                          *");
        System.out.println("* 1 --> \"Añadir nombres al final de la obLista\"              *");
        System.out.println("* 2 --> \"Añadir un nombre en el n-ésimo lugar de la obLista\" *");
        System.out.println("* 3 --> \"Buscar un nombre\"                                   *");
        System.out.println("* 4 --> \"Listar nombres\"                                     *");
        System.out.println("* 5 --> \"Borrar un nombre\"                                   *");
        System.out.println("* 6 --> \"Borrar todos los nombres de la obLista\"             *");
        System.out.println("**************************************************************");
        EntradaTec op = new EntradaTec();//Creación de un objeto op como instancia de la clase EntradaTec       
        System.out.println("Escriba el número de opción y pulse ENTER");
        String n = op.pedirEntrada();//Asignación al String n la cadena solicitada por la clase pedirEntrada() del objeto op       
        int numOp = Integer.parseInt(n);//Conversión de la cadena n a entero (objeto String --> objeto Integer)   
        int sup = obLista.getSize();//Obtención del índice superior de la obLista
       
        switch (numOp){
            case 1:
                    System.out.println("Escriba un nombre, o nada para terminar, y pulse ENTER");
                    obLista.addNombre();                   
                    break;
            case 2:
                    System.out.print("Posición del nombre a insertar en la obLista (no superior a " + sup + "):");
                    String s = op.pedirEntrada();                   
                    int i = Integer.parseInt(s);                   
                    if (i <= sup){obLista.addNombre(i);}
                    else {System.out.println("La posición no debe ser superior a " + sup);                   
                    }
                    break;
            case 3:
                    System.out.print("¿Nombre a buscar en la obLista?:");
                    String nombre = op.pedirEntrada();
                    String respuesta = obLista.Buscar(nombre);
                    System.out.println(respuesta);
                    break;
            case 4:
                    System.out.println("\n\n");                   
                    System.out.println("*********************************");
                    System.out.println("");                   
                    System.out.println("¿Cómo desea presentar la lista, en fila (1) o en columna (2)?");
                    String formato = op.pedirEntrada();
                    if (formato.equals("1")){obLista.listado1();} else {obLista.listado2();}                     
                    break;
            case 5:
                    System.out.print("Posición del nombre a borrar de la obLista (inferior a " + sup + "):");
                    String t = op.pedirEntrada();                   
                    int j = Integer.parseInt(t);
                    obLista.borraNombre(j);       
                    break;                                           
            case 6:
                    obLista.borraLista();
                    break;
            default:
            }
        }   
 }
CLASE QUE CONTIENE EL MÉTODO main PARA INICIAR EL PROGRAMA:

Código: [Seleccionar]

/**************************************************
 *      POO en Java - PROGRAMA CON 4 CLASES       *
 *      ===================================       *
 * EJERCICIO SOBRE MÉTODOS DE LA CLASE ArrayList  *
 *           Autor: Jesús Álvarez Lobo            *
 *        Versión: 0.001 - Fecha: 14/1014         *
 **************************************************/

public class ManejoLista{
   
    public static void main (String [] args){
     
       OptList manejoLista = new OptList();       
       EntradaTec pregunta = new EntradaTec();
       String respuesta;
       
       do{
          manejoLista.opList();
          System.out.println("Desea volver al menú (s) o terminar (n)?");         
          respuesta = pregunta.pedirEntrada();         
          System.out.print('\u000C');}//Borra la consola respetando el menú de opciones         
       while(respuesta.equals("s"));     
    }
}

El siguiente objetivo en la escalada de complejidad sería transformar este programa de forma que en lugar de trabajar con objetos tipo String lo hiciese con un ArrayList<String>, donde el array que sustituye al String (nombres de la lista) del programa actual fuese, por ejemplo, de dimensión 3, con estos datos: (nombre de un piloto de F1, su escudaría, su puntuación en la clasificación general). ¿Alguien se anima?. 

Saludos y mucho ánimo.

[toni_apr]

Hola lobo
Tu ejercicio es una maravilla.

1º Un main que llama a otra clase para presentar el menú y gestionarlo y lo único que hace es preguntar si queremos volver al menú. OK

2º Un menú completo con inserciones de elementos al final y en medio, búsqueda y eliminación de elementos. OK

Y tal como dices:

tiene un código limpio y una interface intuitiva y amigable.

Aunque estás empezando en java, se nota tu bagaje en programación, y no tienes problemas en encontrar y usar métodos apropiados. Ejem.:

lista.add(nombre);
lista.add(i, nombre);

En fin, tu código está perfecto. Solo quiero comentarte un detalle.
Has creado el método
public int getSize(){//Método tipo función (getter) que devuelve el tamaño de la lista
funcional al 100%, un método de tipo función.
Pero quiero recordarte que los métodos que contienen el prefijo 'get', son métodos que devuelven atributos de la clase.
Este método podría confundir y hacer creer que existe un atributo de nombre 'size' en esta clase.
¿Solución? Cambiar el nombre por 'miSize', 'totalSize', etc. Excluyendo siempre el get inicial.

En cuanto a tu propuesta de ejercicio, me gusta. Hablamos.

Saludos

[lobo]

Gracias de nuevo toni_apr por tomarte la molestia de probar e inspeccionar mi código, así como por tu crítica tan estimulante.

Sí, realmente he creado aplicaciones de gran complejidad, además con programación procedimental (sobre todo en VB6). Tal vez algún día consiga traducir este código a java y podríais verlo. Una de estas aplicaciones es para simular y resolver, analítica, numérica y gráficamente todos los problemas posibles en DISPERSIÓN COMPTON (efecto cuántico de la dispersión de fotón y electrón).

Pero en POO soy absolutamente novato y me cuesta un poco entender algunos conceptos. No obstante, el proceso de cualquier aprendizaje es así, paulatino; no se puede pretender entenderlo todo el primer día.

Observo que estudias el código con mucho rigor, y no es ninguna temeridad predecirte un gran futuro como programador,

Gracias por tu colaboración. Seguiremos en contacto.

Te deseo mucho éxito en los estudios y en la vida.

Un cordial saludo.