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

Hola. envío dos clases para este ejercicio.

Clase TestTiposDePiedra con main
/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class TestTiposDePiedra { 
    public static void main (String [] args) {
        float cargaMax = 22800.0f, pesoPalet = 0f;
        System.out.println ("Teniendo en cuenta que un palet ocupa 2.27 m³\n" +
            "He aquí una relación del peso de un palet de cada tipo de piedra.\n" +
            "Y el número de palets de cada piedra que puede cargar el camión \n" +
            "sin sobrepasar la carga máxima de " + cargaMax + " kg.\n" +
            "Piedra________________Peso palet________Palets/Camión");
       
        String msg;
        for (TiposDePiedra tmp: TiposDePiedra.values()) {
            pesoPalet = (2.27f * (float) tmp.getPesoEspecifico());
            msg = tmp.toString();
            msg = msg + relleno (tmp.toString(),22);
            msg = msg + pesoPalet + " kg.";
            msg = msg + relleno (pesoPalet + " kg.",22);
            msg = msg + (int) (cargaMax / pesoPalet);
            System.out.println (msg);
        }
    } // fin del main
    private static String relleno (String texto, int valorMax) {
        String c = "_",salida = "";
        int largo = texto.length();
        for (int i = 0; i < (valorMax - largo); i++) {
            salida = salida + c;
        }
        return salida;
    }
} // Fin de la clase TestTiposDePiedra
Clase TiposDePiedra 'clase enum'
/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public enum TiposDePiedra {             
    CALIZA (1200f),
    MARMOL (1423.55f),
    PIZARRA (1325f),
    CUARZITA (1466.22f);
   
    private final float pesoEspecifico;
    //Constructor
    TiposDePiedra(float pesoEspecifico) {            // Inicializa atributos
        this.pesoEspecifico = pesoEspecifico;
    } // Fin del constructor TiposDePiedra

    public float getPesoEspecifico () { return pesoEspecifico; }
}
Saludos

Hola.
Envío ejercicio CU00681B con tipos enumerados. 5 clases.
Clase con main. MatricularVehiculos
/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class MatricularVehiculos {
    public static void main (String [] args) {
        ListaDeVehiculos listaVehiculos = new ListaDeVehiculos();
        presentacion(listaVehiculos);
        Vehiculo miCoche = new Vehiculo();
        EnteroIntervalos numero = new EnteroIntervalos(); // devuelve un número entero
        int numElemento=0;
        Mensaje mensaje = new Mensaje("");
        String respuesta = "", siNo= "";
        if (listaVehiculos.size() > 0) {
            mensaje.muestra("La lista se ha incializado con " + listaVehiculos.size() + " vehículos.");
        } else {
            mensaje.muestra("La lista de vehículos está vacía.");
        }
        boolean continuarBucle = true;
        do {
            respuesta = mensaje.responde("\tPulse la opción deseada.\n\t" +
                "M -> Matricular nuevo vehículo.\n\t" +
                "V -> Visualizar vehículos matriculados.\n\t" +
                "R -> Retirar vehículo de la lista.\n\t" +
                "INTRO -> Salir/Terminar/Exit");
            if (respuesta.length() == 0) {
                continuarBucle = false;
            } else if (respuesta.substring(0,1).toUpperCase().equals("M")) {
                miCoche = new Vehiculo();
                miCoche.escogerMarca();
                miCoche.escribirMatricula();
                siNo = mensaje.responde ("Los datos del vehículo son:\n\t" +
                    "Marca: " + miCoche.getMarca() + "\n\t" +
                    "Matrícula: " + miCoche.getMatricula() + "\n" +
                    "¿Desea añadir este vehículo a la lista de los matriculados? S/N",0);
                if (siNo.length() == 0) {
                    mensaje.muestra ("No se añade el vehículo a la lista. Respuesta en blanco.");
                } else if (siNo.substring(0,1).toUpperCase().equals("S")) {
                    listaVehiculos.add (miCoche);
                    mensaje.muestra ("Vehículo añadido a la lista.");
                } else {
                    mensaje.muestra ("No se añade el vehículo a la lista.");
                }
            } else if (respuesta.substring(0,1).toUpperCase().equals("V")) {
                listaVehiculos.muestraLista();
            } else if (respuesta.substring(0,1).toUpperCase().equals("R")) {
                numElemento = numero.enteroAceptado(mensaje.responde("Introduzca el número del vehículo a retirar/remover entre 1 y " +
                        listaVehiculos.size(),0),1,listaVehiculos.size());
                if (numElemento < 1) {
                    mensaje.muestra ("No se ha retirado ningún vehículo.");
                } else {
                    miCoche = listaVehiculos.remove(numElemento-1);
                    mensaje.muestra("Se ha eliminado el vehículo: \n" +
                        "Marca: " + miCoche.getMarca() + " Matrícula: " + miCoche.getMatricula());
                }
            } else {
                mensaje.muestra ("Opción incorrecta.");
            }
        } while (continuarBucle); 
        mensaje.muestra ("\tTerminada la matriculación de vehículos.");
    } // fin delmain

    private static void presentacion (ListaDeVehiculos lista) {
        Mensaje mensaje = new Mensaje("Esta Vd. en el departamento de matriculación de vehículos.\n" +
                "Siga las intrucciones por favor.\n");
        Vehiculo miCoche;
        String respuesta = "", siNo = "";
        siNo = mensaje.responde ("La lista de vehículos matriculados está vacía.\n" +
            "¿Desea introducir algunas matrículas de forma aleatoria?. (S/N)",0);
        if (siNo.length() == 0) {
            mensaje.muestra ("Respuesta en blanco. La lista queda vacía.");
        } else if (siNo.substring(0,1).toUpperCase().equals("S")) {
            EnteroIntervalos numero = new EnteroIntervalos(); // devuelve un número entero
            int numeroCochesMatriculados = numero.enteroAceptado(mensaje.responde(
                        "¿Cuántos coches quiere poner en la lista?. Escriba un valor entre 1 y 15:",0),1,16);
            if ( numeroCochesMatriculados < 1) {
                mensaje.muestra ("Valor fuera de rango. La lista queda vacía.");
            } else {
                lista.addVehiculosAleatorios(numeroCochesMatriculados);
                mensaje.muestra ("Se ha creado lista de vehículos");
            }
        } else { // se pulsa cualquier tecla distinta de 'S'
            mensaje.muestra ("La lista queda vacía.");
        }
    }
} // Fin de la clase MatricularVehiculos
Clase ListaDeVehiculos (gestiona una colección de vehículos)
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;
/**
 * Gerstiona una lista de vehículos dentro de un ArrayList
 * @author (Toni)
 * @version (0)
 */
public class ListaDeVehiculos {             // Atributos de la clase ListaDeVehiculos
    private ArrayList <Vehiculo> listaVehiculos;
    //Constructor para objetos de la clase ListaDeVehiculos
    public ListaDeVehiculos() {            // Inicializa atributos
        listaVehiculos = new ArrayList <Vehiculo> ();
    } // Fin del constructor ListaDeVehiculos
/**
 * Añade el vehículo aportado a la lista
 */
    public void add (Vehiculo miVehiculo) {
        listaVehiculos.add (miVehiculo);
    }
/**
 * Elimina el vehículo de la posición indicada
 */
    public Vehiculo remove (int posicion) {
        if (posicion >= 0 && posicion < listaVehiculos.size()) {
            return listaVehiculos.remove(posicion);
        } else {
            return null;
        }
    }
/**
 * Devuelve el vehículo de la posición indicada
 */
    public Vehiculo getVehiculoDeLaLista (int posicion) {
        if (posicion <= 0 && posicion < listaVehiculos.size()) {
            return listaVehiculos.get(posicion);
        } else {
            return null;
        }
    }
/**
 * Devuelve el tamaño de la lista de vehículos
 */
    public int size () {
        return listaVehiculos.size();
    }
/**
 * Muestra por pantalla la lista de vehículos con su marca y matrícula
 */
    public void muestraLista () {
        Iterator <Vehiculo> itV = listaVehiculos.iterator();
        Vehiculo tmpV = new Vehiculo();
        int contador = 0;
        System.out.println ("Id.\tMarca\tMatrícula");
        while (itV.hasNext()) {
            tmpV = itV.next();
            System.out.println ((++contador) + "\t" + tmpV.getMarca() + "\t" + tmpV.getMatricula());
        }
    }
/**
 * Añade a la lista el número de vehículos indicados de forma aleatoria.
 */
    public void addVehiculosAleatorios (int cantidad) {
        Vehiculo miCoche;
        String matricula;
        Random numAlea = new Random();
        for (int i = 0; i < cantidad; i++) {
            miCoche = new Vehiculo();
            miCoche.escogerMarca(numAlea.nextInt(5)); // 5 marcas diferentes
            matricula = "";
            for (int j = 0; j < 4; j++) {
                matricula = matricula + (char) (numAlea.nextInt(10) + 48); // añade cifras del 0 al 9
            }
            matricula = matricula + "-";
            for (int j = 0; j < 3; j++) {
                matricula = matricula + (char) (numAlea.nextInt(26) + 65); // añade caracteres de la A a la Z
            }
            miCoche.setMatricula (matricula);
            add (miCoche);
        }
    }
} // Fin de la clase ListaDeVehiculos
Clase Vehiculo
/**
 * Clase para identificar un vehículo por su marca (un tipo enumerado) y su matrícula
 * @author (Toni)
 * @version (0)
 */
public class Vehiculo {             // Atributos de la clase Vehiculo
    enum MarcaDeVehiculo {FORD,TOYOTA,SUZUKI,RENAULT,SEAT};
    private String matricula;
    private MarcaDeVehiculo marca;
   
    public Vehiculo () {
        matricula = "";
        marca = null;
    } //fin del constructor

    public void setMatricula (String matricula) { this.matricula = matricula; }

    public void setMarca (MarcaDeVehiculo marca) { this.marca = marca; }

    public String getMatricula () { return matricula; }

    public MarcaDeVehiculo getMarca () { return marca; }

    /**
     * Método 'escogerMarca' para escoger por teclado un tipo enumerado como valor para el atributo 'marca'
     */
    public void escogerMarca () {
        String msg = "Marca de vehículo establecida con éxito.";
        Mensaje mensaje = new Mensaje ("Escoja la marca del vehículo pulsando el número asociado.");
        String valor = mensaje.responde ("\t0 FORD. 1 TOYOTA. 2 SUZUKI. 3 RENAULT. 4 SEAT.",0);
        switch (valor) {
            case "0": setMarca (MarcaDeVehiculo.FORD); break;
            case "1": setMarca (MarcaDeVehiculo.TOYOTA); break;
            case "2": setMarca (MarcaDeVehiculo.SUZUKI); break;
            case "3": setMarca (MarcaDeVehiculo.RENAULT); break;
            case "4": setMarca (MarcaDeVehiculo.SEAT); break;
            default: msg = "Marca de vehículo incorrecta. Inténtelo otra vez."; break;
        } // fin del switch
        mensaje.muestra (msg);
    }
/**
 * Método 'escogerMarca' sobrecargado. Recibe como parámetro el valor que se había de escoger por teclado en el otro método.
 */
    public void escogerMarca (int numero) {
        switch (numero) {
            case 0: setMarca (MarcaDeVehiculo.FORD); break;
            case 1: setMarca (MarcaDeVehiculo.TOYOTA); break;
            case 2: setMarca (MarcaDeVehiculo.SUZUKI); break;
            case 3: setMarca (MarcaDeVehiculo.RENAULT); break;
            case 4: setMarca (MarcaDeVehiculo.SEAT); break;
            default:  break;
        } // fin del switch
    }
/**
 * Pide por teclado la matrícula que se asignará al atributo 'matricula'
 */
    public void escribirMatricula () {
        Mensaje mensaje = new Mensaje ("Introduzca la matrícula del vehiculo:");
        setMatricula (mensaje.responde ("\t",0));
        mensaje.muestra ("Se ha establecido la matrícula \"" + matricula + "\" para el vehículo.");
    }
} // Fin de la clase Vehiculo
Clase Mensaje (presenta mensajes y devuelve entradas de teclado)
import java.util.Scanner;
/**
 * Detalles de la clase. El método presenta mensajes por pantalla... y devuelve entradas de teclado
 * @author (Toni)
 * @version (0)
 */
public class Mensaje { // Atributos de la clase Mensaje
    private String texto;
    private int valor;
    /**
     * Mostrará el texto con salto de línea final.
     */
    public Mensaje (String frase) { //Constructor 1 parámetro para objetos de la clase Mensaje. Inicializa atributos
        texto = frase;
        valor = 1;
        muestra (texto, valor);
    }

    /**
     * Muestra el texto con salto de línea o no según param.
     * Valores param:
     * 0 = Sin salto de línea.
     * 1, u otro valor = Con salto de línea.
     */ 
    public Mensaje (String frase, int param) {
        texto = frase;
        valor = param;
        muestra (texto, valor);
    }
    // Siguen los setters para los atributos de la clase Mensaje
    public void setTexto (String texto) { this.texto = texto; }

    public void setValor (int valor)    { this.valor = valor; }
    // Ahora los getters para los atributos de la clase Mensaje
    public String getTexto ()           { return texto; }

    public int getValor ()              { return valor; }

    // Y seguidamente, procedimientos y funciones varios.
    /**
     * Mostrar el texto con salto de línea (sin segundo parámetro)
     */   
    public void muestra (String frase) {
        muestra (frase, 1);
    }// fin de muestra 1 parámetro

    /**
     * Valores param:
     * 0 = Sin salto de línea.
     * 1, u otro valor = Con salto de línea.
     */   
    public void muestra (String frase, int param) {
        texto = frase;
        valor = param;
        if (valor == 0) { System.out.print (texto + " ");
        }          else { System.out.println (texto); }
    }// fin de muestra 2 parámetros

    /**
     * Sin segundo parámetro el mensaje incluirá salto de línea. Devuelve entrada de teclado
     */
    public String responde (String frase) {
        return responde (frase, 1);
    }// fin de responde 1 parámetro

    /**
     * Valores param:
     * 0 = Sin salto de línea + entrada por teclado.
     * 1, u otro valor = Con salto de línea + entrada por teclado.
     */
    public String responde (String frase, int param) {
        texto = frase;
        valor = param;
        muestra (texto, valor);
        Scanner entradaEscaner = new Scanner(System.in);
        return entradaEscaner.nextLine();
    }// fin de responde 2 parámetros
} // Fin de la clase Mensaje
Clase EnteroIntervalos (devuelve un entero dentro de un intervalo)
/**
 * Recibe un String, lo convierte a int entre los intervalos aportados.
 * <br>Si no puede hacerlo, devuelve valor fuera del rango especificado = (valorInicial - 1)
 * @author (Toni)
 * @version (0)
 */
public class EnteroIntervalos {             
    public int enteroAceptado (String entrada, int valorInicial, int valorFinal) {
        int entero = 0;
        char c =' ';
        entrada = entrada.trim();
        if (entrada.length() == 0) { return valorInicial - 1;  }
        for (int i = 0; i < entrada.length(); i++) {
            c = entrada.charAt(i);
            if (c==48 || c==49 || c==50 || c==51 || c==52 || c==53 || c==54 || c==55 || c==56 || c==57) {  // solo dígitos del 0 al 9
            } else    { return valorInicial - 1; } // ha aparecido un caracter no dígito
        }
        entero = (int)Integer.valueOf(entrada);
        if (entero < valorInicial || entero >= valorFinal) { return valorInicial - 1; } // entero fuera del rango desde-hasta
        return entero;       
    } // fin de enteroAceptado
} // Fin de la clase EnteroIntervalos
Saludos.

Ejercicio para crear la documentación de la clase.

Clase MiniCalculadoraEjemplo
/**
 * Esta clase es un ejercicio para crear la documentación de la clase que contiene los dos métodos de una Minicalculadora.
 * <br/>Esta clase no tiene atributos y el constructor está vacío.
 * @author (Toni)
 * @version (28/7/2014/A)
 * @see <a href = "https://www.aprenderaprogramar.es/index.php?option=com_content&view=article&id=646:&catid=68:&Itemid=188"/> aprenderaprogramar.com - Documentar proyectos java con javadoc comentarios... </a>
 */
public class MiniCalculadoraEjemplo {           
    /**
     * Devuelve el valor absoluto del parámetro.
     * @param valorD. El valor tipo 'double' con el que trabaja el método.
     * @return El valor absoluto (sin signo) y de tipo 'double' del parámetro aportado.
     */
    public double valorAbsoluto (double valorD) {
        return Math.abs(valorD);
    }
    /**
     * Devuelve la raiz cuadrada del parámetro.
     * @param valorD. El valor dipo 'double' con el que trabaja el método.
     * @return La raiz cuadrada en formato 'double' del parámetro aportado.
     */
    public double raizCuadrada (double valorD) {
        return Math.sqrt(valorD);
    }
} // Fin de la clase MiniCalculadoraEjemplo


Hola César.
Vuelvo a enviar el ejercicio de polimorfismo, pero continuo con el mismo warning
He cambiado como me indicabas el tipo a recorrer  en  la línea:

Iterator<HashSet> itHS = tmpSet.iterator();

por:

Iterator<String> itHS = tmpSet.iterator();

Pero verás que me da el mismo warning.
He hecho varias cosas, todas infructuosas.
He reescrito el código, he descansado y vuelto a retomar el problema, he intentado tomar otra vía, pero ciñéndome a los requerimientos del ejercicio he vuelto al mismo guión.

Así que te pido me ilumines, a ver que concepto me pierdo,o tal vez abordar el problema desde otro lado.

Saludos.

Clase EjercicioPolimorfismoN
import java.util.*;
// import java.util.ArrayList;
// import java.util.HashSet;
// import java.util.TreeSet;
/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class EjercicioPolimorfismoN {           
    public static void main (String [] args) {
        System.out.println ("\nVersion N:");
        // Declaración del ArrayList
        ArrayList<Set> planetasYCifras = new ArrayList<Set>();
        String [] planetasArr = {"sol", "luna", "saturno", "pluton"};
        // Declaración del HashSet + inicialización
        HashSet<String> planetas = new HashSet<String>(Arrays.asList(planetasArr));
        // Declaración del TreeSet
        TreeSet<Integer> cifras = new TreeSet<Integer>();
        int [] cifrasArr = {2, 8, 5, -1, 16};
        // Rellenado del TreeSet
        for (Integer cifr: cifrasArr) {
            cifras.add (cifr);
        }
        // Rellenado del ArrayList con el HashSet y el TreeSet
        planetasYCifras.add (planetas);
        planetasYCifras.add (cifras);
        // Iterador para el ArrayList
        Iterator<Set> itPYC = planetasYCifras.iterator();
        Set tmpSet;
        Object tmpObj;
        // Recorre el ArrayList
        while (itPYC.hasNext()) {
            tmpSet = itPYC.next();
            // Discriminar tipo de datos en ArrrayList para mostrar su contenido
            tmpObj = null; //
            if (tmpSet instanceof java.util.HashSet) {
                System.out.println ("El objeto tmpSet es de la clase: " +tmpSet.getClass() + ".\nElementos del HashSet "  + tmpSet.size() );
 //                 HashSet hs = (HashSet) tmpSet;
                Iterator<String> itHS = tmpSet.iterator();
                //                 Iterator<HashSet> itHS = tmpSet.iterator();
                while (itHS.hasNext()) {
                    if (tmpObj != null) { System.out.print (", "); }
                    tmpObj = itHS.next();
                    System.out.print (tmpObj );
                }

                System.out.println (".");   
            } else if (tmpSet instanceof java.util.TreeSet) {

                System.out.println ("El objeto tmpSet es de la clase: " +tmpSet.getClass() + ".\nElementos del TreeSet "  + tmpSet.size() );
                TreeSet ts = (TreeSet) tmpSet; // conversión de tipo para usar descendingIterator

                Iterator<Integer> itTS = ts.descendingIterator();
                // //                 Iterator<TreeSet> itTS = ts.descendingIterator();
                while (itTS.hasNext()) {
                    if (tmpObj != null) { System.out.print (", "); }
                    tmpObj = itTS.next();
                    System.out.print (tmpObj );
                }
                System.out.println (".");
            }
        } // fin del while itPYC
    } // fin del main
} // Fin de la clase EjercicioPolimorfismoN

Hola Alex.

Lo de los nombres de las variables es un lastre que arrastro, pongo nombres para mí, pero se que si quiero entender el código un mes más tarde, tengo que hacer lo que dices.
Poner nombres que se expliquen solos, así de fácil.

En cuanto a los packages. Voy a poner todas las clases en el package por defecto, y listo.

Gracias por tus comentarios
Saludos.

Presento las clases de la lección de los 'packages' ejercicio CU00674B del curso básico de programación orientada a objetos de aprenderaprogramar.

Clase TestPackage. Esta clase incorpora 3 líneas 'import' con la ruta de cada package para acceder las clases allí contenidas.

package CU00674B.formas;
import CU00674B.formas.formas1dimension.*;
import CU00674B.formas.formas2dimension.*;
import CU00674B.formas.formas3dimension.*;
/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class TestPackage { 
    public static void main (String [] args) {
        // Objetos formas1dimension
        Recta miRecta = new Recta();
        Curva miCurva = new Curva();
        // Objetos formas2dimension
        Triangulo miTriangulo = new Triangulo();
        Cuadrilatero miCuadrilatero = new Cuadrilatero();
        Elipse miElipse = new Elipse();
        Parabola miParabola = new Parabola();
        Hiperbola miHiperbola = new Hiperbola();
        // Objetos formas3dimension
        Cilindro miCilindro = new Cilindro();
        Cono miCono = new Cono();
        Esfera miEsfera = new Esfera();
    } // fin del main
} // Fin de la clase TestPackage


Clase Recta

package CU00674B.formas.formas1dimension;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Recta {             // Atributos de la clase Recta
    int x, y, largo;
    float angulo;
    //Constructor para objetos de la clase Recta
    public Recta() {            // Inicializa atributos
        x = 10;
        y = 20;
        largo = 30;
        angulo = 45.0f;
    } // Fin del constructor Recta
    public Recta (int x, int y, int largo, float angulo) {
        this.x = x;
        this.y = y;
        this.largo = largo;
        this.angulo= angulo;
    }
    // Siguen los setters para los atributos de la clase Recta
    public void setX (int x) { this.x = x; }

    public void setY (int y) { this.y = y; }

    public void setLargo (int largo) { this.largo = largo; }

    public void setAngulo (float angulo) { this.angulo= angulo; }
    // Ahora los getters para los atributos de la clase Recta
    public int getX () { return x; }

    public int getY () { return y; }

    public int getLargo () { return largo; }

    public float getAngulo () { return angulo; }
    // Y seguidamente, metodos varios.

} // Fin de la clase Recta


Clase Curva

package CU00674B.formas.formas1dimension;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Curva {
    public Curva() {            // Inicializa atributos
       
    } // Fin del constructor Curva

} // Fin de la clase Curva


Clase Triangulo

package CU00674B.formas.formas2dimension;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Triangulo {
    public Triangulo() {            // Inicializa atributos
       
    } // Fin del constructor Triangulo
} // Fin de la clase Triangulo


Clase Cuadrilatero

package CU00674B.formas.formas2dimension;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Cuadrilatero {
    public Cuadrilatero() {            // Inicializa atributos
       
    } // Fin del constructor Cuadrilatero
} // Fin de la clase Cuadrilatero


Clase Elipse

package CU00674B.formas.formas2dimension;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Elipse {
    public Elipse() {            // Inicializa atributos
       
    } // Fin del constructor Elipse

} // Fin de la clase Elipse


Clase Parabola

package CU00674B.formas.formas2dimension;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Parabola {
    public Parabola() {            // Inicializa atributos
       
    } // Fin del constructor Parabola
} // Fin de la clase Parabola


Clase Hiperbola

package CU00674B.formas.formas2dimension;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Hiperbola {
    public Hiperbola() {            // Inicializa atributos
       
    } // Fin del constructor Hiperbola
} // Fin de la clase Hiperbola


Clase Cilindro

package CU00674B.formas.formas3dimension;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Cilindro { 
    public Cilindro() {            // Inicializa atributos
       
    } // Fin del constructor Cilindro
} // Fin de la clase Cilindro


Clase Cono

package CU00674B.formas.formas3dimension;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Cono {
    public Cono() {            // Inicializa atributos
       
    } // Fin del constructor Cono
 
} // Fin de la clase Cono


Clase Esfera

package CU00674B.formas.formas3dimension;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Esfera {
    public Esfera() {            // Inicializa atributos
       
    } // Fin del constructor Esfera
 
} // Fin de la clase Esfera


Hola Ogramar.
Si, eso es lo que me pasa.
No se porque, creía que una clase debe tener siempre atributos, que formaba parte de la filosofía de una clase.
Así ya me gusta más. Hasta ahora me encorsetaba arrastrando unos atributos arriba y abajo.

Lo de escoger nombres más adecuados. También he de mejorarlo.

Tus comentarios me han ilustrado. Gracias.

Envío 3 clases:
Clase TextCirculo con el main
/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class TestCirculo {             // Atributos de la clase TestCirculo

    //Constructor para objetos de la clase TestCirculo
    public TestCirculo() {            // Inicializa atributos

    } // Fin del constructor TestCirculo

    // Siguen los setters para los atributos de la clase TestCirculo

    // Ahora los getters para los atributos de la clase TestCirculo

    // Y seguidamente, metodos varios.
    public static void main (String [] args) {
        Mensaje mensaje = new Mensaje ("\tA ver señores. ¿Quién quiere probar.? \n" +
                "\tDenme un RADIO o un DIÁMETRO, y haré filigranas.");
        boolean masCalculos = true;            // Condición del while
        String opcionRD = "";                  // opción Radio o Diámetro
        String tmpRD ="", digitosString = "";  // digitosString. Valor numérico introducido por teclado
        double valorRD = 0.0d;                 // valor del radio/diámetro
        Circulo cir = new Circulo();
        do {
            opcionRD = mensaje.responde ("\nDígame, que me da Vd. Radio o Diámetro: (R/D)",0);
            if (opcionRD.length() == 0) {      // Se ha pulsado INTRO
                mensaje.muestra ("Si no quiere hacer más pruebas. Terminamos.");
                break; // saliendo del while
            }
            opcionRD = opcionRD.substring(0,1).toUpperCase();
            if (!opcionRD.equals("R") && !opcionRD.equals("D")) {
                mensaje.muestra ("Esa opción no está disponible. Si quiere terminar, pulse INTRO directamente.");
            } else {
                if (opcionRD.equals("R")) { tmpRD = "Radio"; } else { tmpRD = "Diámetro"; }
                digitosString = numeroValido(mensaje.responde ("Introduzca su " + tmpRD + " por favor:",0));
                if (digitosString == null) {
                    mensaje.muestra ("Introduzca un valor numérico válido. Por favor, inténtelo de nuevo.");
                } else {
                    valorRD = Double.valueOf(digitosString);
                    if (opcionRD.equals("D")) { valorRD = valorRD / 2; }
                    mensaje.muestra ("El área para este círculo, es de:........ " + cir.AreaCirculo(valorRD) + " unidades cuadradas.");
                    mensaje.muestra ("La circunferencia de este círculo, es de: " + cir.LongitudCircunferencia(valorRD) + " unidades."); 
                }
            }     
        } while (masCalculos);       // fin del while
    } // fin del main
    private static String numeroValido(String cad) {
        boolean punto = false;
        char c =' ';
        cad = cad.trim();
        for (int i = 0; i < cad.length(); i++) {
            c = cad.charAt(i);
            if (c==48 || c==49 || c==50 || c==51 || c==52 || c==53 || c==54 || c==55 || c==56 || c==57) {  // solo dígitos
            } else if (c==46)  { // el punto decimal
                if ( punto ) { return null; }  // no puede haber más de un punto decimal
                punto = true;
            } else           { return null; } // ha aparecido un caracter no dígito
        }
        return cad;
    } // fin del soloDigitos
} // Fin de la clase TestCirculo
Clase Circulo, usando 'static final' (un solo espacio de memoria para el atributo en todos los objetos de la clase y valor constante que no se puede modificar)
/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class Circulo {             // Atributos de la clase Circulo
    private static final double PI = 3.1416d;
    private double radio;
    //Constructor para objetos de la clase Circulo
    public Circulo() {            // Inicializa atributos
        radio = 1;
    } // Fin del constructor Circulo
    public Circulo (double radio) {
        this.radio = radio;
    }
    // Siguen los setters para los atributos de la clase Circulo
    public void setRadio (double radio)                 { this.radio = radio; }
    // Ahora los getters para los atributos de la clase Circulo
    public double getRadio ()                           { return radio; }

    // Y seguidamente, metodos varios.
    public double AreaCirculo ()                         { return (PI * radio * radio); }

    public double AreaCirculo (double radioX)            { return (PI * radioX * radioX); }

    public double LongitudCircunferencia ()              { return (2 * PI * radio); }

    public double LongitudCircunferencia (double radioX) { return (2 * PI * radioX); }
   
} // Fin de la clase Circulo
Clase Mensaje para entradas de teclado
import java.util.Scanner;
/**
 * Detalles de la clase. El método presenta mensajes por pantalla... y devuelve entradas de teclado
 * @author (Toni)
 * @version (0)
 */
public class Mensaje { // Atributos de la clase Mensaje
    private String texto;
    private int valor;
    /**
     * Mostrará el texto con salto de línea final.
     */
    public Mensaje (String frase) { //Constructor 1 parámetro para objetos de la clase Mensaje. Inicializa atributos
        texto = frase;
        valor = 1;
        muestra (texto, valor);
    }

    /**
     * Muestra el texto con salto de línea o no según param.
     * Valores param:
     * 0 = Sin salto de línea.
     * 1, u otro valor = Con salto de línea.
     */ 
    public Mensaje (String frase, int param) {
        texto = frase;
        valor = param;
        muestra (texto, valor);
    }
    // Siguen los setters para los atributos de la clase Mensaje
    public void setTexto (String texto) { this.texto = texto; }

    public void setValor (int valor)    { this.valor = valor; }
    // Ahora los getters para los atributos de la clase Mensaje
    public String getTexto ()           { return texto; }

    public int getValor ()              { return valor; }

    // Y seguidamente, procedimientos y funciones varios.
    /**
     * Mostrar el texto con salto de línea (sin segundo parámetro)
     */   
    public void muestra (String frase) {
        muestra (frase, 1);
    }// fin de muestra 1 parámetro

    /**
     * Valores param:
     * 0 = Sin salto de línea.
     * 1, u otro valor = Con salto de línea.
     */   
    public void muestra (String frase, int param) {
        texto = frase;
        valor = param;
        if (valor == 0) { System.out.print (texto + " ");
        }          else { System.out.println (texto); }
    }// fin de muestra 2 parámetros

    /**
     * Sin segundo parámetro el mensaje incluirá salto de línea. Devuelve entrada de teclado
     */
    public String responde (String frase) {
        return responde (frase, 1);
    }// fin de responde 1 parámetro

    /**
     * Valores param:
     * 0 = Sin salto de línea + entrada por teclado.
     * 1, u otro valor = Con salto de línea + entrada por teclado.
     */
    public String responde (String frase, int param) {
        texto = frase;
        valor = param;
        muestra (texto, valor);
        Scanner entradaEscaner = new Scanner(System.in);
        return entradaEscaner.nextLine();
    }// fin de responde 2 parámetros
} // Fin de la clase Mensaje
En el ejercicio se hace la siguiente pregunta:

¿Es posible crear un método en la clase Circulo para establecer el valor de numeroPi? ¿Por qué?

Respuesta: No. Porque se ha declarado con la palabra clave 'final' que quiere decir 'constante' que no se puede modificar.

Hola, esta es mi respuesta al ejercicio CU00670B

El mensaje de error:
bad operand types for binary operator "*"
first type: int; second type: java.lang.String

nos dice que el primer operando del operador binario '*' es de tipo int y el segundo de tipo String. Son operandos incompatibles
Debemos hacer una conversión de tipos, por ejemplo sustituir le línea errónea

System.out.println ("El doble del número introducido es: " + 2 * entradaUsuario);

por:
System.out.println ("El doble del número introducido es: " + 2 * Float.valueOf(entradaUsuario));

Ahora los dos tipos continúan siendo distintos, pero compatibles, el compilador no tiene ningún problema en convertir el int a Float. Y el resultado será Float.

------------------
Ejercicio CU00672B Trabajar con números aleatorios.
Clase AdivinaNumero.
import java.util.Random;
/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class AdivinaNumero {             // Atributos de la clase AdivinaNumero
   
    //Constructor para objetos de la clase AdivinaNumero
    public AdivinaNumero() {            // Inicializa atributos
       
    } // Fin del constructor AdivinaNumero
   
    // Siguen los setters para los atributos de la clase AdivinaNumero
   
    // Ahora los getters para los atributos de la clase AdivinaNumero
   
    // Y seguidamente, metodos varios.
    public static void main (String [] args) {
        Random numAlea;
        numAlea = new Random();
        int numeroX = numAlea.nextInt(100) + 1; // numeroX estará entre 1 y 100
        Mensaje mensaje = new Mensaje ("Se ha generado un número aleatorio entreo entre 1 y 100, intente adivinarlo.");
        int intentos = 0, respuesta = -1;
        boolean intentaDeNuevo = true;
        do {
           respuesta = Integer.valueOf(mensaje.responde ("Intento nº" + (++intentos) + ":",0));
            mensaje.muestra (rellenaConCaracter(respuesta, '¬') + (respuesta) );
            if (respuesta == numeroX) {
                mensaje.muestra ("Respuesta correcta. Enhorabuena.");
                intentaDeNuevo =  false;
            }
            else if (respuesta < numeroX) {
                mensaje.muestra ("No ha acertado: El número es MAYOR. Pruebe otra vez.");
            }
            else {
                mensaje.muestra ("No ha acertado: El número es MENOR. Pruebe otra vez.");
            }
        } while (intentaDeNuevo); // fin del while
    } // fin del main
   
    private static String rellenaConCaracter (int numero, char c) {
        String respuesta ="";
        for (int i = 0; i < numero; i++) {
            respuesta = respuesta + c;
        }
        return respuesta;
    } // fin de RellenaConCaracter
} // Fin de la clase AdivinaNumero
Clase Mensaje
import java.util.Scanner;
/**
 * Detalles de la clase. El método presenta mensajes por pantalla... y devuelve entradas de teclado
 * @author (Toni)
 * @version (0)
 */
public class Mensaje { // Atributos de la clase Mensaje
    private String texto;
    private int valor;
    /**
     * Mostrará el texto con salto de línea final.
     */
    public Mensaje (String frase) { //Constructor 1 parámetro para objetos de la clase Mensaje. Inicializa atributos
        texto = frase;
        valor = 1;
        muestra (texto, valor);
    }

    /**
     * Muestra el texto con salto de línea o no según param.
     * Valores param:
     * 0 = Sin salto de línea.
     * 1, u otro valor = Con salto de línea.
     */ 
    public Mensaje (String frase, int param) {
        texto = frase;
        valor = param;
        muestra (texto, valor);
    }
    // Siguen los setters para los atributos de la clase Mensaje
    public void setTexto (String texto) { this.texto = texto; }

    public void setValor (int valor)    { this.valor = valor; }
    // Ahora los getters para los atributos de la clase Mensaje
    public String getTexto ()           { return texto; }

    public int getValor ()              { return valor; }

    // Y seguidamente, procedimientos y funciones varios.
    /**
     * Mostrar el texto con salto de línea (sin segundo parámetro)
     */   
    public void muestra (String frase) {
        muestra (frase, 1);
    }// fin de muestra 1 parámetro

    /**
     * Valores param:
     * 0 = Sin salto de línea.
     * 1, u otro valor = Con salto de línea.
     */   
    public void muestra (String frase, int param) {
        texto = frase;
        valor = param;
        if (valor == 0) { System.out.print (texto + " ");
        }          else { System.out.println (texto); }
    }// fin de muestra 2 parámetros

    /**
     * Sin segundo parámetro el mensaje incluirá salto de línea. Devuelve entrada de teclado
     */
    public String responde (String frase) {
        return responde (frase, 1);
    }// fin de responde 1 parámetro

    /**
     * Valores param:
     * 0 = Sin salto de línea + entrada por teclado.
     * 1, u otro valor = Con salto de línea + entrada por teclado.
     */
    public String responde (String frase, int param) {
        texto = frase;
        valor = param;
        muestra (texto, valor);
        Scanner entradaEscaner = new Scanner(System.in);
        return entradaEscaner.nextLine();
    }// fin de responde 2 parámetros
} // Fin de la clase Mensaje
Saludos.

Hola Sergio.
He visto tu código y lo he probado. Funciona sin errores.

Quiero comentarte cosas que has hecho y podías mejorar.

En el método setEdad() has incluido el código para mostrar los años que le faltan al médico para tener una edad múltiplo de 5.
Te confirmo que es un código válido y funciona. Pero, si relees el enunciado del ejercicio, verás que se pide crear un método.

Define un método de nombre
“calculoParaMultiploEdad” que no recibe parámetros y es tipo procedimiento

Este método ha de ser como entenderás independiente del método setEdad().
Nota: los métodos que empiezan por set... y get... de las clases, usados para establecer y obtener los atributos de la clase respectivamente, tienen un único propósito: set para establecer y get para devolver los valores de los atributos, y para nada más.
Piensa que con tu código, para saber si la edad del médico será múltiplo de 5 dentro de pocos años, has de cambiar su edad con setEdad()
De la otra forma, en cualquier momento, incluso sin conocer la edad del médico, el método calculoParaMultiploEdad() siempre te devolverá los años que le faltan al médico para que su edad sea múltiplo de 5.

Por último veo que usas un atributo de nombre 'folioidentificacion', válido como cualquier otro, cumple con la excepción de no empezar con una cifra.
Pero, hay una convención entre otras, al escribir código en java de:
A la hora de poner nombres a las variables y métodos con nombres compuestos: Empezar con minúscula y las siguientes palabras empezarlas con mayúscula (práctica que facilita su lectura)

Las convenciones son opcionales, yo puedo poner a una variable que acumula el número de vecinos de una escalera el nombre de: "String hpg5u;" también puedo poner "String numerodevecinos;" o "String numeroDeVecinos; o "String numeroTotalDeVecinosDeLaEscalera;"
Los dos últimos ejemplos cumplen la convención.

Saludos y adelante.