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

Mi consulta es sobre cómo debo leer (interpretar) la información del API.
En este caso analicemos los dos métodos utilizados en el ejemplo resuelto, los cuales  pertenecen a la clase Collections.

Analicemos el siguiente método:

static <T extends Comparable<? super T>> void       sort(List<T> list)

Lo que entiendo de este método es que:
el método es un método estático tipo procedimiento (no devuelve nada).
Es aplicable sobre objetos tipo T, los que implementan la interface Comparable (o heredan una clase que la implemente).
Y que a su vez esa interface Comparable está definida sobre objetos que heredan la clase T.
El parámetro que se debe pasar al método es un objeto tipo List definido sobre objetos tipo T.

¿ Esto es correcto ?

Analizando la información del API de este otro método:

static <T> void              sort(List<T> list, Comparator<? super T> c)

entiendo que: es una método estático tipo procedimiento también.
Los parámetros que se deben pasar al método son dos:
El primero, un objeto tipo List definido sobre objetos tipo T.
El segundo, un objeto tipo Comparator definido sobre objetos que hereden la clase T.

¿ Esto es correcto ?

Hola!

Me ha quedado una duda al leer la lección (CU00910C) donde se desarrolla un ejemplo resuelto implementando la interface Cloneable, perteneciente al package lang del API Java.

Supongamos que al ejemplo lo reescribo de la siguiente manera:

Por ejemplo, si al código del ejercicio resuelto, lo reescribiéramos de la forma:

/* Ejemplo Clase e Interfaz Cloneable aprenderaprogramar.com */

 public class Persona implements Cloneable{

   public int dni, edad;

      public Persona( int d, int e) {     this.dni = d;       this.edad = e;     }

 }

no tendríamos errores de compilación, ¿ por qué ? porque la interface Clonable no declara ningún método abstracto, por lo tanto no me obliga a implementar ninguno en mi clase concreta. ¿Pero y entonces de dónde sale el método clone() ? El método clone() es un método heredado de la clase Object. Pero al no estar declarado en la Interface clonable() no estoy obligado a implementarlo.

Lo que no entiendo es: si el API de java, define una interface clonable() para que la utilicemos para clonar, ¿por qué no entonces declarar la clase abstracta clone()? ¿por qué no exigir al que implemente la interface que es obligatoria su implementación?

Mi versión del Ejercicio propuesto en la Entrega Nº95. Ejercicio CU00695B.
(para descargar pulsar en el icono de archivo estando logeado en el foro)

Mi versión del Ejercicio propuesto en la Entrega Nº92. Ejercicio CU00692B.

Clase Profesor
/**
 * Clase Profesor
 *
 * @author (RaGa)
 * @version (20150427)
 */
public class Profesor
{
    // Declaración de campos de instancia.
    private String nombre;
    private int edad;
    private int añosConsolidados;

    /**
     * Constructor 1 para objetos de clase Profesor
     */
    public Profesor(String nombre, int edad, int añosConsolidados){
        this.nombre=nombre;
        this.edad=edad;
        this.añosConsolidados=añosConsolidados;
    }
   
    /**
     * Constructor 2 para objetos de clase Profesor
     */
    public Profesor(){
        nombre="";
        edad=0;
        añosConsolidados=0;
    }

    /**
     * métodos setters
     */
   
    public void setAñosConsolidados(int añosConsolidados){
        this.añosConsolidados=añosConsolidados;
    }
   
    public void setNombre(String nombre){
        this.nombre=nombre;
    }
   
    public void setEdad(int edad){
        this.edad=edad;
    }
   
    /**
     * métodos getters
     */
   
    public int getAñosConsolidados(){
        return añosConsolidados;
    }
   
    public String getNombre(){
        return nombre;
    }
   
    public int getEdad(){
        return edad;
    }
   
    /**
     * métodos varios
     */
   
    public String mostrarDatos(){
        return ("\nNombre: "+nombre+", Edad: "+edad+", Años Consolidados: "+añosConsolidados+", ");
    }
   
    public double obtenerSalarioBase(){
        return (725+(añosConsolidados*33.25));
    }
   
}// fin de la clase

Clase ProfesorEmerito
/**
 * Clase ProfesorEmerito
 *
 * @author (RaGa)
 * @version (20150427)
 */
public class ProfesorEmerito extends Profesor
{
    // Declaración de campos de instancia.
    private int añosEmerito;

    /**
     * Constructor 1 para objetos de clase ProfesorEmerito
     */
    public ProfesorEmerito(String nombre, int edad, int añosConsolidados, int añosEmerito){
        super(nombre,edad,añosConsolidados);
        this.añosEmerito=añosEmerito;
    }
   
    /**
     * Constructor 2 para objetos de clase ProfesorEmerito
     */
    public ProfesorEmerito(int añosEmerito){
        super();
        añosEmerito=añosEmerito;
    }

    /**
     * métodos setters
     */
   
    public void setAñosEmerito(int añosEmerito){
        this.añosEmerito=añosEmerito;
    }
   
    /**
     * métodos getters
     */
   
    public int getAñosEmerito(){
        return añosEmerito;
    }

   
    /**
     * métodos varios
     */
   
    public String mostrarDatos(){
        return (super.mostrarDatos()+" Años Emérito: "+añosEmerito+", ");
    }
   
    public double obtenerSalarioBase(){
        return (super.obtenerSalarioBase()+(47.80*añosEmerito));
    }
   
}// fin de la clase

Clase TestHerencia6
import java.util.*;

/**
 * Clase TestHerencia6
 *
 * @author (RaGa)
 * @version (20150427)
 */
public class TestHerencia6
{
    // Declaracion de variables de instancia.
   

    /**
     * Constructor de clase
     */
    public TestHerencia6(){ //vacío
    }

    /**
     * método main
     */
    public static void main(){
        ArrayList<Profesor> listaProfesoresAcademia;
        listaProfesoresAcademia=new ArrayList<Profesor>();
       
        // Carga de datos de Profesores
        Profesor profe1 = new Profesor("Danilo Salazar Quintana",28,2);
        Profesor profe2 = new ProfesorEmerito("Cándido Tolosa Martínez",63,28,3);
        ProfesorEmerito profe3 = new ProfesorEmerito("María Rosa Díaz Díaz",60,27,2);
       
        // Carga de ListaProfesoresAcademia
        listaProfesoresAcademia.add(profe1);
        listaProfesoresAcademia.add(profe2);
        listaProfesoresAcademia.add(profe3);
       
        // Muestra de ListaProfesoresAcademia
        System.out.println("\fLista de Profesores de la Academia");
        for (Profesor tmp:listaProfesoresAcademia){
            System.out.println(tmp.mostrarDatos());
            System.out.println("Salario Base= "+tmp.obtenerSalarioBase());
        }
       
    }// fin de main
   
}// fin de clase


Mi versión del Ejercicio propuesto en la Entrega Nº87. Ejercicio CU00687B.
(archivo adjunto CU00687B.rar, descarga estando logeado en el foro)

Diagrama de clases en archivo adjunto "DiagramaDeClases.jpg"

Mi versión del Ejercicio propuesto en la Entrega Nº81. Ejercicio CU00681B.

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: 31/03/15
 * @version: 01
 */

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 matrícula y la marca del vehículo.
     * @param el parámetro valorMatricula es de tipo String y corresponde a la matrícula del vehiculo.
     * @param el parámetro opcionMarca 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 setVehiculo(String valorMatricula, int opcionMarca){
        matricula = valorMatricula;
        switch (opcionMarca){
            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
    }
   
    // Getters
    /**El método retorna la matrícula del vehículo.
     * @return la variable retornada es de tipo String.
     */
    public String getMatricula(){ return matricula; }
    /**El método retorna 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: 31/03/15
 * @version: 01
 */


public class TestVehiculo{
    //Declaración de campos de instancia.
    private Vehiculo miVehiculo;
    private int tmpMarca;
    private boolean continuarEnWhile=true;
   

    public TestVehiculo(){ // Constructor de clase vacío.
        miVehiculo = new Vehiculo();
    }
   
    /** Método ComprobadorVehiculo.
     * A través de la interface consola se establece comunicación con el usuario y se pone a prueba la clase Vehiculo.
     *
     */
   
    public void ComprobadorVehiculo(){
        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;}
            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.setVehiculo(GestionadorEntradasTeclado.leerString(),tmpMarca);
       
        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
Clase GestionadorEntradasTeclado
/**Clase de caracter public. Sirve para leer los valores ingresados por el usuario a través del teclado. Cuenta con dos métodos tipo función: uno devuelve un objeto tipo String ingresado por el usuario a través del teclado, y el otro devuelve un valor tipo int ingresado por el usuario a través del teclado.
 * @author: RaGa
 * @date: 15/03/15
 * @version: 01
 */

import java.util.Scanner;

public class GestionadorEntradasTeclado{
    //Declaracion de campos de instancia de la clase vacío.
   
    public GestionadorEntradasTeclado(){ // Constructor de clase vacío.
    }
   
    /**Devuelve un objeto tipo String correspondiente al valor ingresado por el usuario a través del teclado.
     * @return retorna un objeto tipo String.
     */
     static String leerString(){
        Scanner scannerTeclado = new Scanner (System.in);
        String valorTeclado = scannerTeclado.nextLine();
        return valorTeclado;
    }
   
    /**Devuelve un valor tipo int correspondiente al valor ingresado por el usuario a través del teclado.
    * @return retorna un valor tipo int.
    */
    static int leerInt(){
       Scanner scannerTeclado = new Scanner (System.in);
       int valorTeclado = scannerTeclado.nextInt();
       //String valorTmp = scannerTeclado.nextLine(); // para vaciar el buffer.
       return valorTeclado;
    }
     
} // Fin de la clase
Readme.txt

PROJECT TITLE: CU00681B
PURPOSE OF PROJECT: Probar la clase Vehiculo
VERSION or DATE: 31/03/15
HOW TO START THIS PROJECT: Instanciar un objeto tipo TestVehiculo y llamar al método ComprobadorVehiculo.
AUTHORS: RaGa
USER INSTRUCTIONS: Siga la instrucciones y mensajes que se presentan a través de la consola.

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º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!

Buenas tardes.

Este es mi primera participación activa en el foro.

Vengo leyendo todas las Entregas y haciendo los Ejercicios propuestos.

Gracias al foro he podido ir comparando (y aprendiendo) con los programas que se comparten; lo mismo con las observaciones que se hacen sobre ellos.

Este es mi versión para el Ejercicio de la Entrega Nº62 (CU00662B).


public class CU00662B{ // Definición de clase
    //Declaracion de campos de instancia vacía

    public static void main (String[] args){ // función main
        System.out.print("Ingrese Primera Palabra :");
        String palabra1 = Teclado.leer();
        System.out.print("Ingrese Segunda Palabra :");
        String palabra2 = Teclado.leer();
        System.out.println("");
       
        int limiteSuperior;
        int limiteInferior;
        int palabraCorta;
       
        if(palabra1.length() < palabra2.length()){
            limiteInferior = palabra1.length();
            palabraCorta = 1;
            limiteSuperior = palabra2.length();}
            else
            {limiteInferior = palabra2.length();
             palabraCorta = 2;
             limiteSuperior = palabra1.length();}
           
        for (int i=0;i<limiteSuperior;i++){
           
            if (i<limiteInferior){
                System.out.print("¿Letra "+(i+1)+" igual en las dos palabras? ");
                System.out.print(palabra1.substring(i,i+1).equals(palabra2.substring(i,i+1))+"\n");
            }
            else{
                System.out.print("La palabra "+palabraCorta+" no tiene letra "+(i+1)+"\n");
            }
           
        } // fin bucle for
                       
    } // fin main
   
} // fin clase

El método que sirve para ingresar los datos por teclado está en otro clase.

Mi intención además de intentar "pensar en POO" persigue el objetivo de la eficiencia.

Creería que de esta manera, es decir que el objeto Scanner sea local de un método, ahorra recursos ya que una vez que devuelve el String deja de existir. No sucedería lo mismo si la instanciación del objeto Scanner se hiciera dentro del main.

¿Son correctas estas apreciaciones?

import java.util.Scanner;

public class Teclado{
    //Declaracion de campos de instancia de la clase
    public Teclado(){
    }
   
     static String leer(){
        Scanner scannerTeclado = new Scanner (System.in);
        String valorTeclado = scannerTeclado.nextLine();
        return valorTeclado;
    }
   
       
} // Fin de la clase