Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

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:
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:

/* 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Ú):

/* 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:

/**************************************************
 *      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.

En primer lugar SALUDOS a todos, pues soy nuevo en el FORO.

También soy nuevo en POO (aunque he programado en otros lenguajes, como VB6 y LOGO).

Considero esencial sentar bien las bases conceptuales para construir sobre seguro, de ahí la siguiente pregunta:

¿Se puede decir que un OBJETO es una variable (tipo objeto) cuyo tipo es la CLASE (las clases definen tipos) de la que deriva el objeto?.

De ser así, ya que una variable es un espacio reservado en memoria, ¿que espacio ocuparía una variable tipo objeto?. Supongo dependerá de la complejidad del objeto, pero ¿se puede evaluar el tamaño en memoria?.

Muchas gracias.