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

Graves errores! (no se me pueden escapar cosas tan gruesas).
Veamos ahora si con los cambios en la clase Vehiculo y TestVehiculo queda solucionado.
No publico nuevamente la clase GestionadorEntradasTeclado ya que es la misma.
Gracias toni !

Clase Vehiculo
enum MarcaDeVehiculos {FORD,TOYOTA,SUZUKI,RENAULT,SEAT};

/** Clase Vehiculo. Cada objeto se compone de la marca del vehículo y su matrícula.
 * @author: RaGa
 * @date: 02/04/15
 * @version: 02
 */

public class Vehiculo{
    //Declaración de campos de instancia
    private String matricula;
    private MarcaDeVehiculos marca;
   
    public Vehiculo(){ // Constructor de clase
    }
   
    // Setters
    /**El método sirve para setear la marca del vehículo.
     * @param el parámetro valorMarca es de tipo int y corresponde a la marca del vehículo. Sus posibles opciones son:
     * 1 = FORD
     * 2 = TOYOTA
     * 3 = SUZUKI
     * 4 = RENAULT
     * 5 = SEAT
     */
    public void setMarca(int valorMarca){
       
        switch (valorMarca){
            case 1:
            marca = MarcaDeVehiculos.FORD;
            break;
            case 2:
            marca = MarcaDeVehiculos.TOYOTA;
            break;
            case 3:
            marca = MarcaDeVehiculos.SUZUKI;
            break;
            case 4:
            marca = MarcaDeVehiculos.RENAULT;
            break;
            case 5:
            marca = MarcaDeVehiculos.SEAT;
            break;
        } // fin Switch
    }
   
    /**El método sirve para setear la matrícula del vehículo.
     * @param el parámetro valorMatricula es de tipo String y corresponde a la matrícula del vehiculo.
     */
    public void setMatricula(String valorMatricula){
        matricula = valorMatricula;
    }
   
    // Getters
    /**El método devuelve la matrícula del vehículo.
     * @return la variable retornada es de tipo String.
     */
    public String getMatricula(){ return matricula; }
   
    /**El método devuelve la marca del vehículo.
     * @return la variable retornada es de tipo MarcaDeVehiculo.
     */
    public MarcaDeVehiculos getMarca(){ return marca; }
   
   
} //fin de la clase
Clase TestVehiculo
/** clase TestVehiculo. Sirve para poner a prueba la clase Vehiculo.
 * @author: RaGa
 * @date: 02/04/15
 * @version: 02
 */


public class TestVehiculo{
    //Declaración de campos de instancia vacía.
   
    public TestVehiculo(){ // Constructor de clase vacío.
    }
   
    /** Método main.
     * A través de la interface consola se establece comunicación con el usuario y se pone a prueba la clase Vehiculo.
     *
     */
    public static void main(String[] args){
       
        Vehiculo miVehiculo = new Vehiculo();
        int tmpMarca;
        boolean continuarEnWhile=true;
         
        System.out.println("\fBienvenido, a continuación se va a registrar su vehículo");
        System.out.println("");
       
        do{
            System.out.println("Por favor introduzca la marca según la siguiente Tabla: ");
            System.out.println("1. FORD");
            System.out.println("2. TOYOTA");
            System.out.println("3. SUZUKI");
            System.out.println("4. RENAULT");
            System.out.println("5. SEAT");
       
            tmpMarca = GestionadorEntradasTeclado.leerInt();
            if((0<tmpMarca)&&(tmpMarca<6)){continuarEnWhile=false; miVehiculo.setMarca(tmpMarca);}
            else{System.out.println("");
                 System.out.println("Su opción es erroena, por favor vuelva a intentarlo...");
                }
               
        }while(continuarEnWhile);

        System.out.println("");
        System.out.println("Por favor, ahora introduzca la Matrícula del vehículo: ");
        miVehiculo.setMatricula(GestionadorEntradasTeclado.leerString());
       
        System.out.println("\fSu vehículo quedó registrado como: ");
        System.out.print("Marca: "+miVehiculo.getMarca().toString()+"\n");
        System.out.print("Matricula: "+miVehiculo.getMatricula());
        System.out.println("");
        System.out.println("Gracias por registrar su vehículo. Hasta luego!");

    } // fin main
}// fin de la clase
Readme.txt

PROJECT TITLE: CU00681B
PURPOSE OF PROJECT: Probar la clase Vehiculo
VERSION or DATE: 02/04/15
HOW TO START THIS PROJECT: Ejecutar el método main de la clase TestVehiculo.
AUTHORS: RaGa
USER INSTRUCTIONS: Siga la instrucciones y mensajes que se presentan a través de la consola.

Mi versión del Ejercicio propuesto en la Entrega Nº80. Ejercicio CU00680B.

Clase MiniCalculadoraEjemplo
import java.lang.Math;
import java.util.Scanner;

/** Esta clase tiene métodos que le permiten realizar el ingreso de un valor tipo double a través del teclado por parte del usuario, y realizar dos operaciones matemáticas sobre ese valor.
 * @author: RaGa
 * @version: 01
 * @date:30/03/15
 */

public class MiniCalculadoraEjemplo{
    // Declaración de campos de instancia
    private double valorIngresado;
   
    public MiniCalculadoraEjemplo(){ // Constructor de clase
    }

   
    /** Lee el valor de tipo double que el usuario ingrese por teclado.
     * @return Retorna el valor tipo double ingresado por teclado por el usuario.
     */
    public double leerDouble(){
        Scanner scannerTeclado = new Scanner (System.in);
        double valorTeclado = scannerTeclado.nextDouble();
        String leerIntro = scannerTeclado.nextLine(); // sirve para borrar el intro del buffer
        return valorTeclado;
    }
   
    /** Calcula el valor absoluto del valor que se pasa como argumento.
     * @param Recibe como argumento un número tipo double.
     * @return Se retorna el valor absoluto del argumento de entrada.
     */
    public double calcularValorAbsoluto(double valor){
        return Math.abs(valor);
    }
   
   
    /** Calcula la raíz cuadrada del valor que se pasa como argumento.
     * @param Recibe como argumento un número tipo double.
     * @return Se retorna la raíz cuadrada del argumento de entrada.
     */
    public double calcularRaizCuadrada(double valor){
        return Math.sqrt(Math.abs(valor));
    }
   
} //fin de la clase
Clase TestMiniCalculadoraEjemplo
/**Esta clase sirve para probar la clase MiniCalculadoraEjemplo.
 * @author: RaGa
 * @version: 01
 * @date: 30/03/15
 */

public class TestMiniCalculadoraEjemplo{
    //Declaracion de campos de instancia de la clase
   
   
    public TestMiniCalculadoraEjemplo(){ // Constructor de clase
    }
   
    /**Este método sirve para probar todos los métodos de la clase MiniCalculadoraEjemplo mediante una interfaz con el usuario.
     *
     */
    public static void main(String[] args){
        MiniCalculadoraEjemplo calculadora = new MiniCalculadoraEjemplo();
        double valorIngresado;
       
        System.out.println("\fIngrese un valor numérico por favor:");
        System.out.println("");
        valorIngresado = calculadora.leerDouble();
        System.out.println("El valor absoluto de "+valorIngresado+" es "+calculadora.calcularValorAbsoluto(valorIngresado));
        System.out.println("Y su raíz cuadrada es "+calculadora.calcularRaizCuadrada(valorIngresado));
    }
   
     
} // Fin de la clase
README.TXT

PROJECT TITLE: Proyecto Documentación.
PURPOSE OF PROJECT: Este proyecto sirve para ejercitar la utilización de la documentación de Java.
VERSION or DATE: 30/03/15
HOW TO START THIS PROJECT: Ejecutar el método main de la Clase TestMiniCalculadoraEjemplo.
AUTHORS: RaGa
USER INSTRUCTIONS: Seguir las instrucciones y mensajes que aparecen por consola.

Gracias Alex por venir en nuestro auxilio.
Perfecto entonces, y muy interesante lo que nos revelas acerca de los algoritmos de comprobación de tipos, es como mirar por la rendija la propia cocina del compilador.

Tengo una consulta que me surge respecto de lo que me sugieres cuando dices:

Otra cosa, esta declaración:

        ArrayList<Set> miLista; // Declaración de los objetos.
        HashSet<String> objHashSet;
        TreeSet<Integer> objTreeSet;


Es más adecuada así:

        List<Set> miLista; // Declaración de los objetos.
        Set<String> objHashSet;
        Set<Integer> objTreeSet;

Entiendo que iré captando y asimilando las bondades y beneficios del polimorfismo conforme vaya avanzando en las posteriores Lecciones y ejercitaciones, pero por lo pronto -y por las comprobaciones que realicé en virtud de tu sugerencia- puedo advertir algo y corrígeme si estoy equivocado.

Al declarar e instanciar el objeto miLista de la siguiente manera:

ArrayList<Set> miLista;
miLista = new ArrayList<Set>;

el objeto miLista podrá usar tanto los métodos correspondientes a la clase ArrayList, como los métodos correspondientes a la interface List, por ser la interface List implementada por la clase ArrayList, cierto?

Ahora bien, si en cambio el objeto miLista fuera declarado e instanciado de la siguiente manera:

List<Set> miLista;
miLista = new ArrayList<Set>;

el objeto miLista podrá usar solo los métodos de la interface Set, pero no los métodos de la clase ArrayList, cierto?.

¿Es correcto lo que digo? A simple vista sería como un "mal negocio" pero sospecho que los beneficios vienen por otro lado que por ahora no visualizo.
Hasta este momento veo como beneficio que un objeto declarado como List podrá recibir como argumento todo objeto cuya clase implemente la interface List (que no es poca cosa).

Mis versiones del Ejercicio propuesto en la Entrega Nº78. Ejercicio CU00678B.

Presento dos códigos a los cuáles llegué luego de muchos tropiezos y muchas relecturas.


El primer código que compila sin Warnings es el siguiente:

import java.util.*;

public class Ejercicio_Polimorfismo{
    // Declaración de los campos de instancia.
    public Ejercicio_Polimorfismo(){ // Constructor de clase
    }
   
    public static void main (String[] args){
        ArrayList<Set> miLista; // Declaración de los objetos.
        HashSet<String> objHashSet;
        TreeSet<Integer> objTreeSet;
       
       
        miLista = new ArrayList<Set>(); // Instanciación de los objetos
        objHashSet = new HashSet<String>();
        objTreeSet = new TreeSet<Integer>();
       
       
        objHashSet.add("Sol"); // Añade elementos al objeto tipo HashSet
        objHashSet.add("Luna");
        objHashSet.add("Saturno");
       
        objTreeSet.add(2); // Añade elementos al objeto tipo TreeSet
        objTreeSet.add(8);
        objTreeSet.add(5);
               
        miLista.add(objHashSet); // Se agrega a la lista el objeto HashSet y el objeto TreeSet
        miLista.add(objTreeSet);

        System.out.print("\f"); // Borra la pantalla
       

        for (Set objetoSet:miLista){ // Se recorre el objeto ArrayList con for each
           
        Iterator itElementos = objetoSet.iterator(); // No se especifica tipo de dato a recorrer
       
            while(itElementos.hasNext()){ // Recorro cada elemento del ArrayList con un iterador
                System.out.println(itElementos.next());
            }
           
        } // fin for each
                     
       
    } // fin main
   
   
} // fin de la clase

En este segundo código aparecen los incómodos Warnings:

import java.util.*;

public class Ejercicio_Polimorfismo2{
    // Declaración de los campos de instancia.
    public Ejercicio_Polimorfismo2(){ // Constructor de clase
    }
   
    public static void main (String[] args){
        ArrayList<Set> miLista; // Declaración de los objetos.
        HashSet<String> objHashSet;
        TreeSet<Integer> objTreeSet;
       
       
        miLista = new ArrayList<Set>(); // Instanciación de los objetos
        objHashSet = new HashSet<String>();
        objTreeSet = new TreeSet<Integer>();
       
       
        objHashSet.add("Sol"); // Añade elementos al objeto tipo HashSet
        objHashSet.add("Luna");
        objHashSet.add("Saturno");
       
        objTreeSet.add(2); // Añade elementos al objeto tipo TreeSet
        objTreeSet.add(8);
        objTreeSet.add(5);
               
        miLista.add(objHashSet); // Se agrega a la lista el objeto HashSet y el objeto TreeSet
        miLista.add(objTreeSet);

        System.out.print("\f"); // Borra la pantalla
       

        for (Set objetoSet:miLista){ // Se recorre el objeto ArrayList con for each
               
            if(objetoSet instanceof HashSet){ // Si el elemento de la lista contiene un objeto HashSet lo recorro con un for each
                for (String tmp:(Set<String>)objetoSet){
                    System.out.println(tmp);
                }
            }
           
            if(objetoSet instanceof TreeSet){ // Si el elemento de la lista contiene un objeto TreeSet lo recorro con un for each
                for (Integer tmp:(Set<Integer>)objetoSet){
                    System.out.println(tmp);
                }
            }
 
                   
        } // fin for each
    } // fin main
} // fin de la clase
Saco como conclusión lo siguiente, y necesitaría ayuda para saber si estoy bien encaminado en las deducciones:

Primer código:

Se usa un for each para recorrer los objetos Set del ArrayList<Set>, y para recorrer esos objetos Set se usa un iterador donde no se especifica el tipo a recorrer. Este "truco" lo vi en un ejercicio del foro y sinceramente inquieta desde algún punto de vista: si bien uno se tranquiliza porque la compilación deja de darnos los warnings luego de machacarnos la cabeza varias horas seguidas, nos surge la inquietante idea de pensar ¿acaso hay cosas que se pueden hacer sin que estén documentadas en el Api de Java? Pues si uno consulta en el Api la interface Iterable:

Interface Iterable<T>

No hay ningún indicio de que <T> sea opcional, sino que interpreto que es obligatorio definir el tipo a recorrer. ¿Cómo se justifica entonces?


Segundo código:

Para el recorrido de los objetos Set se usa un for each, y para recorrer cada uno de esos objetos Set también se usa for each; vale decir que es un for each anidado dentro de otro for each, lo cual estaría bien desde el punto de vista que for each permite recorrer colecciones, y el tipo ArrayList implementa la interface Collection y interface Set tiene como superInterface la interface Collection. De esta manera justificaría poder usar for each en cada recorrido.

Ahora bien: aparecen los warnings. Si bien (yo) estoy seguro que no cometo ningún error de conversión de tipos, cada vez que extraigo del ArrayList<List> un objeto que yo estoy seguro que es un -supongamos- HashSet y lo quiero almacenar en un atributo de tipo HashSet, el compilador me lo va a advertir ya que él (el compilador) en tiempo de compilación no está seguro de que ese objeto Set que estoy extrayendo del ArrayList<List> en verdad sea un HashSet.

¿Es por eso que salta el warnings, verdad?

Mi versión del Ejercicio propuesto en la Entrega Nº67. Ejercicio CU00667B.

clase CantanteFamoso
public class CantanteFamoso{
    // Declaración de los campos de instancia
    private String nombre;
    private String discoConMasVentas;
   
    public CantanteFamoso(){ // Constructor de clase vacio
    }

// SETTERS   
   
    public void setNombre(String valorNombre){
        nombre = valorNombre;
    }
   
    public void setDiscoConMasVentas (String valorDiscoConMasVentas){
        discoConMasVentas = valorDiscoConMasVentas;
    }
   
// GETTERS

    public String getNombre(){ return nombre; }
    public String getDiscoConMasVentas() { return discoConMasVentas; }
   
   
} // Fin de la clase
clase ListaCantantesFamosos
import java.util.ArrayList;


public class ListaCantantesFamosos{
   //Declaración de campos de instancia
   ArrayList<CantanteFamoso> listaCantantesFamosos;
   
   public ListaCantantesFamosos(){ //Constructor de clase
       listaCantantesFamosos = new ArrayList<CantanteFamoso>();
   }
   
   
   public void addListaCantante(CantanteFamoso valorCantante){ //Agrega un objeto CantanteFamoso a la Lista
       listaCantantesFamosos.add(valorCantante);
   }
   
   
} // fin de la clase

clase GestionadorEntradasTeclado
import java.util.Scanner;

public class GestionadorEntradasTeclado{
    //Declaracion de campos de instancia de la clase vacia
   
    public GestionadorEntradasTeclado(){ // Constructor de clase
    }
   
     static String leer(){
        Scanner scannerTeclado = new Scanner (System.in);
        String valorTeclado = scannerTeclado.nextLine();
        return valorTeclado;
    }
     
} // Fin de la clase
clase Test
import java.util.Iterator;

public class Test{
    //Declaración de campos de instancia vacío
 
   public Test(){ //Constructor de clase vacío
   }

   private static CantanteFamoso AgregarCantante(){ // Crea nuevo objeto CantanteFamoso de manera manual. Se devuelve el objeto.
       //Declaración de variables locales del método
       CantanteFamoso tmpCantanteFamoso;
       
       tmpCantanteFamoso = new CantanteFamoso(); // Instanciación del objeto CantanteFamoso
       
       System.out.println("");
       System.out.println("Ingrese Nombre del Cantante:");
       tmpCantanteFamoso.setNombre(GestionadorEntradasTeclado.leer());
       System.out.println("Ingrese su Disco con más ventas:");
       tmpCantanteFamoso.setDiscoConMasVentas(GestionadorEntradasTeclado.leer());
       return tmpCantanteFamoso;
   } // fin de método 
 
   
   private static void mostrarLista(ListaCantantesFamosos tmpLista){ // Muestra la Lista completa
       //Declaración de variables locales del método
       CantanteFamoso tmpCantante;
       Iterator<CantanteFamoso> it;
       it = tmpLista.listaCantantesFamosos.iterator();
       
       System.out.println("");
       while(it.hasNext()){
           tmpCantante = it.next();
           System.out.println("Nombre: "+tmpCantante.getNombre()+". Disco más vendido: "+tmpCantante.getDiscoConMasVentas());
       }
   }  // fin de método

   
    public static void main (String[] args){ // método main
        //Declaración de variables locales
        ListaCantantesFamosos listaOchentosa;
        CantanteFamoso tmpCantante;
        String respuesta;
           
        listaOchentosa = new ListaCantantesFamosos(); // Instanciación de la Lista
       
        tmpCantante = AgregarCantante(); // Creación del primer objeto CantanteFamoso
        listaOchentosa.addListaCantante(tmpCantante); // Agrego el primer objeto a la lista
        tmpCantante = AgregarCantante(); // Creación del segundo objeto CantanteFamoso
        listaOchentosa.addListaCantante(tmpCantante); // Agrego el segundo objeto a la lista
       
        System.out.println("");
        System.out.println("La lista inicial contiene los siguientes datos:"); // Mostrar la Lista inicial
        mostrarLista(listaOchentosa);
       
        do{
            tmpCantante = AgregarCantante(); // Creación de un nuevo objeto CantanteFamoso
            listaOchentosa.addListaCantante(tmpCantante); // Agrego el nuevo objeto a la Lista
            System.out.println("");
            System.out.println("La lista actualizada contiene los siguientes datos:"); // Mostrar la Lista actualizada
            mostrarLista(listaOchentosa);
           
            System.out.println("");
            System.out.println("Presione cualquier letra para agregar un nuevo Cantante a la Lista, o presione la letra \"N\" para salir.");
           
            respuesta = GestionadorEntradasTeclado.leer();
           
        }while(!respuesta.equalsIgnoreCase("n"));
       
        System.out.println("Gracias por usuar el software. Hasta luego!");   
   
    } // fin main
   
   
} // fin de la clase
Agradezco como siempre las correcciones y/o sugerencias. Muchas gracias.

Mi versión del Ejercicio propuesto en la Entrega Nº66. Ejercicio CU00666B.

Clase ListaCantantesFamosos
import java.util.ArrayList;

public class ListaCantantesFamosos{
    //Declaración de campos de instancia
    private ArrayList<String> listaCantantes;
   
    public ListaCantantesFamosos(){ // Constructor_1 de clase
        listaCantantes = new ArrayList<String>();
    }
   
        public ListaCantantesFamosos(String nombre1, String nombre2, String nombre3){ // Constructor_2 de clase
        listaCantantes = new ArrayList<String>();
        agregarCantante(nombre1);
        agregarCantante(nombre2);
        agregarCantante(nombre3);
    }
   
    public void agregarCantante(String nombre){
        listaCantantes.add(nombre);
    }
   
    public void recorrerListaCantante(){
    int i=1;
    for(String nombre : listaCantantes){
            System.out.println(i+".- "+nombre);
            i++;
        }
    }
   
} // Fin de la clase
Clase GestionadorEntradasTeclado
import java.util.Scanner;

public class GestionadorEntradasTeclado{
    //Declaracion de campos de instancia de la clase
   
    public GestionadorEntradasTeclado(){ // Constructor
    }
   
     static String leer(){
        Scanner scannerTeclado = new Scanner (System.in);
        String valorTeclado = scannerTeclado.nextLine();
        return valorTeclado;
    }
     
} // Fin de la clase
Clase Test
import java.util.ArrayList;

public class Test{
    //Declaración de campos de instancia.
   
    public static void main (String[] args){
        ListaCantantesFamosos CantantesItalianos;
        CantantesItalianos = new ListaCantantesFamosos("Eros Ramazzotti","Adriano Celentano","Lucio Dalla");
       
        System.out.println("Cantantes Italianos Famosos incluídos en la Lista:");
        CantantesItalianos.recorrerListaCantante();

       
    do{
        System.out.println("");
        System.out.println("Agregue un nuevo cantante italiano a la Lista:");
        CantantesItalianos.agregarCantante(GestionadorEntradasTeclado.leer());
       
        System.out.println("");
        System.out.println("Cantantes Italianos Famosos incluídos en la Lista:");
        CantantesItalianos.recorrerListaCantante();
       
        System.out.println("");
        System.out.println("¿Desea agregar un nuevo cantante a la Lista?");
        System.out.println("(Presione letra \"Y\" para agregar, cualquier otra tecla para Salir)");
    }while (GestionadorEntradasTeclado.leer().equalsIgnoreCase("y"));
   
    System.out.println("");
    System.out.println("Fin del programa. Muchas gracias");       
       
    } // fin main
   
} // fin clase
Saludos!

Leyendo el tutorial CU00657B., me surgen preguntas que intento ir dilucidando retrocediendo en las lecciones y consultado la documentación del API de Java.

Cuando en el ejemplo se instancia un objeto de la siguiente manera:

Scanner entradaEscaner = new Scanner (System.in);    (1)

Interpreto lo siguiente (según voy hurgando en las API de Java)

“in” es un campo de la clase System.
“in” es un objeto de la clase InputStream.

Siguiendo con la lectura de las API de Java, cuando entramos en la clase Scanner vemos que hay Constructores sobrecargados. De todas las posibilidades, vemos que la que se ajusta a nuestra instrucción (1) es:

Scanner(InputStream source)

Es decir que espera como parámetro un objeto de la clase InputStream. Por ello le enviamos como parámetro el objeto “in” (de la clase System).

Ahora bien ¿cuál es la magia que hace que “in” esté prestando atención a lo que sucede en el teclado? Lo que creo es que en este caso, más que mirar a “in” como un objeto con  métodos, tenemos que pensarlo como una referencia, un “apuntar hacia”.

Cuando instanciábamos en los ejercicios anteriores un objeto al que llamábamos “taxi1” de la clase Taxi, bastaba solamente con que la referencia “taxi1” apuntara a ese espacio de memoria donde la información de taxi1 se guardaría. Y ese espacio de memoria daba igual si se reservara al comienzo de la memoria, al medio, o al final de la misma. Siempre que “taxi1” referenciara a ese lugar, cualquiera fuera él, nos bastaba.
En el caso del objeto “in”, creo que ese lugar al que referencia, ese lugar al que apunta, SI IMPORTA.

No tenemos acceso al código de la clase System, pero intuyo que si está configurada que la “entrada estándar” sea el teclado, asigna como referencia de “in” el lugar a donde llega lo que entra por teclado (por así decirlo). Si luego se cambia la entrada estándar, y la nueva entrada estándar es un archivo (supongamos), entonces “in” apuntará a ese archivo.

¿Son correctas estas ideas?.