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

Hola.

Hace tiempo que me ronda por la cabeza una duda que me plantean las opciones para pasar objetos como parámetros a las clases.

Me refiero a estas dos opciones.

La opción A:  (asignación por igualdad)
    public void setPersona(Persona persona1) { 
        persona = new Persona(persona1.getNombre(), persona1.getEdad());
    }
No me plantea ninguna duda. La considero perfecta e incorruptible. Se puede perder el objeto persona1 pues ya ha dado una copia de sus datos.

La duda la tengo en esta opción B: (asignación por identidad)
    public void setPersona(Persona persona1) {
        persona = persona1;
    }
Sobre esta opción he leido que si persona1 cambia más tarde, tal vez ¿? el objeto persona cambie en la misma forma sin haberlo decidido yo así.

He creado el código que adjunto en el mensaje intentando simular ese cambio inesperado, y he aquí la salida que obtengo:

Salida.txt
Fecha: 23/03/2015 > 02:06:01                               
01) Creados agentes: ag[0] = new Agente("A00",30)               y ag[1] = new Agente("A11",31)
02) ag[0]. ref.: ...Agente@143e87d                              ag[1]. ref.: ...Agente@1549b82
03) ····················idAgente: A00                           ····················idAgente: A11
04) ···········ExperienciaPuntos: 30                            ···········ExperienciaPuntos: 31
                                                           
05) Creados perros: pe[0] = new Perro("Labrador",false)         y  pe[1] = new Perro("Dogo",true)
06) pe[0]. ref.: ...Perro@1ad81d2                               pe[1]. ref.: ...Perro@262adc
07) ························Raza: Labrador                      ························Raza: Dogo
08) ················Esterilizado: false                         ················Esterilizado: true
                                                           
09) Creados equipos: eq[0] = new Equipo("Equipo A",ag[0],pe[0]) y  eq[1] = new Equipo("Mister T",ag[1],pe[1])
10) eq[0]<alias,ag,pe>. Ref.: ...Equipo@1c7d5b2                 eq[1]<alias,ag,pe>. Ref.: ...Equipo@9e9a07
11) ·······················Alias: Equipo A                      ·······················Alias: Mister T
12) Ref. agente: ...Agente@143e87d                              Ref. agente: ...Agente@1549b82
13) ····················idAgente: A00                           ····················idAgente: A11
14) ···········ExperienciaPuntos: 30                            ···········ExperienciaPuntos: 31
15) Ref. perro: ...Perro@927633                                 Ref. perro: ...Perro@18e2a42
16) ························Raza: Labrador                      ························Raza: Dogo
17) ················Esterilizado: false                         ················Esterilizado: true
                                                           
18) Asignación de identidad. ag[0] = ag[1]                      Asignación de identidad. pe[0] = pe[1]
19) ag[0]. ref.: ...Agente@1549b82                              ag[1]. ref.: ...Agente@1549b82
20) ····················idAgente: A11                           ····················idAgente: A11
21) ···········ExperienciaPuntos: 31                            ···········ExperienciaPuntos: 31
22) pe[0]. ref.: ...Perro@262adc                                pe[1]. ref.: ...Perro@262adc
23) ························Raza: Dogo                          ························Raza: Dogo
24) ················Esterilizado: true                          ················Esterilizado: true
25) eq[0]<alias,ag,pe>. Ref.: ...Equipo@1c7d5b2                 eq[1]<alias,ag,pe>. Ref.: ...Equipo@9e9a07
26) ·······················Alias: Equipo A                      ·······················Alias: Mister T
27) Ref. agente: ...Agente@143e87d                              Ref. agente: ...Agente@1549b82
28) ····················idAgente: A00                           ····················idAgente: A11
29) ···········ExperienciaPuntos: 30                            ···········ExperienciaPuntos: 31
30) Ref. perro: ...Perro@927633                                 Ref. perro: ...Perro@18e2a42
31) ························Raza: Labrador                      ························Raza: Dogo
32) ················Esterilizado: false                         ················Esterilizado: true
                                                           
33) Objeto nuevo. ag[0] =  new Agente()                         Objeto nuevo. pe[0] = new Perro()
34) ag[0]. ref.: ...Agente@1419cf7                              ag[1]. ref.: ...Agente@1549b82
35) ····················idAgente: Sin Id                        ····················idAgente: A11
36) ···········ExperienciaPuntos: 0                             ···········ExperienciaPuntos: 31
37) pe[0]. ref.: ...Perro@b44131                                pe[1]. ref.: ...Perro@262adc
38) ························Raza: Desconocida                   ························Raza: Dogo
39) ················Esterilizado: false                         ················Esterilizado: true
40) eq[0]<alias,ag,pe>. Ref.: ...Equipo@1c7d5b2                 eq[1]<alias,ag,pe>. Ref.: ...Equipo@9e9a07
41) ·······················Alias: Equipo A                      ·······················Alias: Mister T
42) Ref. agente: ...Agente@143e87d                              Ref. agente: ...Agente@1549b82
43) ····················idAgente: A00                           ····················idAgente: A11
44) ···········ExperienciaPuntos: 30                            ···········ExperienciaPuntos: 31
45) Ref. perro: ...Perro@927633                                 Ref. perro: ...Perro@18e2a42
46) ························Raza: Labrador                      ························Raza: Dogo
47) ················Esterilizado: false                         ················Esterilizado: true


En la salida del programa presento en dos columnas los dos elementos de cada array: agente, perro y equipo creados. Cada clase tiene sus propios atributos y en la clase Equipo dos atributos son de tipo Agente y Perro.

En la clase Equipo el atributo de tipo Perro lo inicializo o modifico siempre con la opción A, citada arriba (establezco una asignación de igualdad), y el atributo de tipo Agente lo modifico con la opción B, (establezco siempre una asignación de identidad).

Cada vez que en la salida se muestra un objeto, adjunta va una referencia que Java crea única para ese objeto (es la respuesta que da el método toString(), no sobreescrito a propósito para poder mostrar esa información.)
Esto que yo llamo referencia, supongo que viene a ser una forma que tiene Java de ligar el objeto en cuestión con los datos de este objeto en la memoria. ¿?
Esta referencia cambia en cada ejecución (la memoria no debe ser igual en todo momento).

En la salida, hasta la línea 17 se crean y presentan los objetos.
En la línea 18 se modifican un objeto de tipo Agente y otro de tipo Perro.
Hasta la línea 32 se vuelven a mostrar todos los objetos.
En la línea 33 se vuelven a modificar los mismos objetos de tipo Agente y de tipo Perro.
Y hasta el final se vuelven a mostrar todos los objetos.


En la información mostrada, se observa lo siguiente:

El objeto pe[1] que no se ha modificado en ningún momento, mantiene sus atributos y su referencia en todo momento. Este mismo objeto al colocarlo dentro del  objeto equipo, cambia su referencia y la mantiene siempre dentro del objeto equipo (pues su asignación ha sido por igualdad).

El objeto pe[0] al que se le han hecho cambios, cambia su contenido y también su referencia en cada cambio. Una vez este objeto se coloca dentro del objeto equipo, cambia su referencia y la mantiene junto con los datos.

El objeto ag[1] que no se ha modificado en ningún momento, mantiene su referencia incluso dentro del objeto equipo (pues su asignación es por identidad), tampoco cambian sus datos.

El objeto ag[0] al que se le han hecho cambios, cambia su contenido cada vez al igual que su referencia. Al colocarlo dentro del objeto equipo, mantiene sus datos en todo momento al igual que su referencia (que es la misma que en su creación antes de modificar el objeto).

El objeto eq[1] mantiene su referencia en todo momento aunque han cambiado algunas referencias internas. Nunca cambian los datos.

El objeto eq[0] mantiene su referencia en todo momento aunque cambian algunas referencias internas así como datos.


Conclusión:
No se pierden datos de objetos pasados como parámetros tanto si se usa la opción A -era previsible-, como la B -en la que tenía dudas-
Si existe el riesgo a que un atributo inicializado o actualizado con un objetoZ revierta su contenido al cambiar externamente el objetoZ debe ser a un nivel muy profundo y que yo no sé reproducir.

Os pido vuestros comentarios después de haber mascullado/triturado todo el mamotreto anterior. Gracias por vuestra opinión.

Saludos

a) ¿Una clase puede heredar de dos clases en Java?
b) ¿Una interface Java puede tener métodos que incluyan una sentencia while? ¿Una interface Java
puede tener métodos que incluyan una sentencia System.out.println?
c) ¿Un objeto Java puede ser del tipo definido por una interface? ¿Un objeto Java puede ser al mismo
tiempo del tipo definido por una interface y del tipo definido por una clase que no implementa la
interface? ¿Un objeto Java puede ser al mismo tiempo del tipo definido por una interface y del tipo
definido por una clase que implementa la interface?

a) ¿Una clase puede heredar de dos clases en Java?

Respuesta a): No.
Solo puede heredar de una clase
-----------------------
b) ¿Una interface Java puede tener métodos que incluyan una sentencia while? ¿Una interface Java puede tener métodos que incluyan una sentencia System.out.println?

Respuesta b): No.
Los métodos de un 'interface' no pueden contener una sentencia 'while' ni ninguna otra, pues al ser todos los métodos de un 'interface' abstractos el cuerpo de su código está vacío.
Por el mismo motivo tampoco pueden contener una sentencia 'System.out.println'
--------------------------
c1) ¿Un objeto Java puede ser del tipo definido por una interface?

Respuesta: Si, singún problema.
-----------------------
c2) ¿Un objeto Java puede ser al mismo tiempo del tipo definido por una interface y del tipo definido por una clase que no implementa la interface?

Respuesta: Si.
Cualquier objeto (instancia de una clase) puede pertenecer a:
 una clase que no tiene relación con otras clases
 una clase que exiende de otra (hereda de otra clase estandard)
 una clase implementa de otra u otras interfaces (hereda de ellas)
 una clase que extiende de otra clase estandard y de otras interfaces

Ejem.
public class Clase1 extends Clase2 implements Interface1 {...}
public class Clase2 {...}

Los objetos de  Clase1 implementan de Interface1 y extienden de Clase2 aunque esta 'Clase2' no implementa de Interface1
------------------------
c3) ¿Un objeto Java puede ser al mismo tiempo del tipo definido por una interface y del tipo definido por una clase que implementa la interface?

Respuesta: Si
Un objeto que pertenece a una clase que implementa de una interface, ya está cumpliendo estas condiciones, está ligada a esta clase y a esta interface.

Saludos

Define una clase Figura de la que hereden otras dos clases denominadas Cuadrado y Círculo. La clase figura debe tener al menos el campo dimensionPrincipal. Las clases Cuadrado y Círculo deben tener al menos un método calcularArea que permita calcular el área a partir de la dimensión principal, utilizando la fórmula matemática correspondiente. Además, sobreescribe el método equals para que dos cuadrados sean iguales si tienen igual dimensión principal, y dos círculos idem. A continuación crea un programa test donde crees varios círculos y cuadrados y hagas comprobaciones de igualdad usando el método equals.

En la clase TestFiguras con main se realizan comparaciones de identidad e igualdad.

Incluyo clases
Figura
Cuadrado
Circulo
TestFiguras
Centrar
Mensa
Enmarcar

Clase Figura
public class Figura {             // Atributos de la clase Figura
    protected float dimensionPrincipal;
    //Constructor para objetos de la clase Figura
    public Figura(float dimensionPrincipal) {            // Inicializa atributos
        this.dimensionPrincipal = dimensionPrincipal;
    } // Fin del constructor Figura

    // Siguen los setters para los atributos de la clase Figura
    public void setDimensionPrincipal (float dimensionPrincipal) { this.dimensionPrincipal = dimensionPrincipal; }
    // Ahora los getters para los atributos de la clase Figura
    public float getDimensionPrincipal () { return dimensionPrincipal; }
    // Y seguidamente, metodos varios.
    public String toString() {
        return "Dimension principal: " + dimensionPrincipal;
    }

    public boolean equals(Object obj) {
        if (obj instanceof Figura) {
            Figura tmpFigura = (Figura) obj;
            if (this.dimensionPrincipal == tmpFigura.dimensionPrincipal) { return true; }
            else                                                         { return false; }
        } else                                                           { return false; }
    }
} // Fin de la clase FiguraClase Cuadrado
public class Cuadrado extends Figura{           

    //Constructor para objetos de la clase Cuadrado
    public Cuadrado(float dimensionPrincipal) {         
        super(dimensionPrincipal);
    } // Fin del constructor Cuadrado
    public float calcularArea() {
        float lado = super.dimensionPrincipal;
        return lado * lado;
    }
    // No se sobreescribe el método toString(), se usará el de la clase padre.
    public float getLado() { return super.dimensionPrincipal; }
    // El atributo 'dimensionPrincipal' es accesible por declararse 'protected' en la clase padre
    public String mostrarDatos() {
        return  super.toString() + " Area: " + calcularArea();
    }
    public boolean equals(Object obj) {
        if (obj instanceof Cuadrado) {
            Cuadrado tmpCuadrado = (Cuadrado)obj;
            if (super.dimensionPrincipal == tmpCuadrado.dimensionPrincipal) { return true; }
            else                                                            { return false; }
        } else                                                              { return false; }
    }
} // Fin de la clase CuadradoClase Circulo
public class Circulo extends Figura{             

    //Constructor para objetos de la clase Circulo
    public Circulo(float dimensionPrincipal) {           
        super(dimensionPrincipal);
    } // Fin del constructor Circulo
    public float calcularArea() {
        float radio = super.dimensionPrincipal;
        return radio * radio * (float)Math.PI;
    }
    // No se sobreescribe el método toString(), se usará el de la clase padre.

    // El atributo 'dimensionPrincipal' es accesible por declararse 'protected' en la clase padre
    public String mostrarDatos() {
        return super.toString() + " Area: " + calcularArea();
    }
    public boolean equals(Object obj) {
        if (obj instanceof Circulo) {
            Circulo tmpCirculo = (Circulo)obj;
            if (super.dimensionPrincipal == tmpCirculo.dimensionPrincipal) { return true; }
            else                                                           { return false; }
        } else                                                             { return false; }
    }
} // Fin de la clase CirculoClase TestFiguras
public class TestFiguras {
    private static boolean mostrarInfo; // Ocultar/mostrar informacion del Area del objeto.

    public TestFiguras() {
        mostrarInfo = false;
    }

    public static void main (String [] args) {
        Cuadrado [] cuad = new Cuadrado[4];
        Circulo [] cir = new Circulo[4];
        for (int i = 0; i < 4; i++) {
            cuad[i] = new Cuadrado((i+1)*10);

            cir[i] = new Circulo((i+.5f)*10);
        }
        System.out.print("\f");
        Centrar.texto("Se presentaran comparaciones de objetos.");
        Centrar.texto("La condicion verdadera se representa con '@' y la falsa con '-'");
        String respuesta = Mensa.responde("\nEsta desactivada la presentacion del area de los objetos.\n" +
                "Si desea activarla, pulse [S]i, cualquier otra tecla mantiene oculta el Area.");
        if (respuesta.length() == 0) { // continua igual
        } else if (respuesta.substring(0,1).equalsIgnoreCase("S")) { mostrarInfo = true; }
        else {  // continua igual
        }
        Enmarcar.texto("Creados 4 cuadrados");
        if (mostrarInfo) {
            for (int i=0;i<4;i++) {
                System.out.println ("Del cuad[" + i + "] tenemos esta información: " + cuad[i].mostrarDatos()); }
        }
        cuadriculaComparacion(cuad);
        Mensa.responde("\nPulsar ENTER para continuar");
        Centrar.texto("¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\\/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯");

        Enmarcar.texto("Se modifica el objeto cuad[2], su atributo 'dimensionPrincipal' se iguala con el del objeto cuad[0]");
        cuad[2].setDimensionPrincipal(10f);
        if (mostrarInfo) {
            for (int i=0;i<4;i++) {
                System.out.println ("Del cuad[" + i + "] tenemos esta información: " + cuad[i].mostrarDatos()); }
        }
        cuadriculaComparacion(cuad);
        Mensa.responde("\nPulsar ENTER para continuar");
        Centrar.texto("¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\\/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯");

        Enmarcar.texto("El objeto cuad[1] es asignado al cuad[3]");
        cuad[3] = cuad[1];
        if (mostrarInfo) {
            for (int i=0;i<4;i++) {
                System.out.println ("Del cuad[" + i + "] tenemos esta información: " + cuad[i].mostrarDatos()); }
        }
        cuadriculaComparacion(cuad);
        Mensa.responde("\nPulsar ENTER para continuar");
        Centrar.texto("¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\\/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯");

        Enmarcar.texto("Creados 4 circulos");
        if (mostrarInfo) {
            for (int i=0;i<4;i++) {
                System.out.println ("Del cir[" + i + "] tenemos esta información: " + cir[i].mostrarDatos()); }
        }
        cuadriculaComparacion(cir);
        Mensa.responde("\nPulsar ENTER para continuar");
        Centrar.texto("¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\\/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯");

        Enmarcar.texto("Se modifica cir[0] su atributo 'dimensionPrincipal' se iguala con el del objeto cir[1]");
        cir[0].setDimensionPrincipal(cir[1].getDimensionPrincipal());
        if (mostrarInfo) {
            for (int i=0;i<4;i++) {
                System.out.println ("Del cir[" + i + "] tenemos esta información: " + cir[i].mostrarDatos()); }
        }
        cuadriculaComparacion(cir);
        Mensa.responde("\nPulsar ENTER para continuar");
        Centrar.texto("¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\\/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯");

        Enmarcar.texto("El objeto cir[2] es asignado al cir[3]");
        cir[3] = cir[2];
        if (mostrarInfo) {
            for (int i=0;i<4;i++) {
                System.out.println ("Del cir[" + i + "] tenemos esta información: " + cir[i].mostrarDatos()); }
        }
        cuadriculaComparacion(cir);
        System.out.println();
        Centrar.texto("¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\\/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯");
        Centrar.texto("Fin de las comparaciones");
    } // fin del main
    private static void cuadriculaComparacion(Figura [] fig) {
        String msg = "",nombre = "";
        if (fig.getClass().toString().contains("Cuadrado")) { 
            nombre = "cuad";
        } else {
            nombre = "cir";
        }

        System.out.println();
        System.out.println("                          Identidad:                               Igualdad:");
        System.out.println("                    " + nombre + "Fila == " + nombre + "Columna              " +
            nombre + "Fila.equals(" + nombre + "Columna)");
        System.out.print("\t");
        for (int i=0; i < 4;i++) { System.out.print("\t " + fig[i].getDimensionPrincipal()); }
        System.out.print("\t");
        for (int i=0; i < 4;i++) { System.out.print("\t " + fig[i].getDimensionPrincipal()); }
        System.out.print("\n\t");
        for (int i=0; i < 4;i++) { System.out.print("\t" + nombre + "[" + i + "]"); }
        System.out.print("\t");
        for (int i=0; i < 4;i++) { System.out.print("\t" + nombre + "[" + i + "]"); }
        System.out.println("\n");

        for (int j=0; j<4; j++) {
            System.out.print( fig[j].getDimensionPrincipal() + "  " + nombre + "[" + j + "]");
            for (int i=0;i<4;i++) {
                if (fig[i] == fig[j]) { msg = "  @"; } else { msg = "  -"; }
                System.out.print ("\t" + msg);
            }
            System.out.print ("\t");
            for (int i=0;i<4;i++) {
                if (fig[i].equals(fig[j])) { msg="  @"; } else { msg="  -"; }
                System.out.print ("\t" + msg);
            }
            System.out.println();
        }
    }
} // Fin de la clase TestFiguras
Clase Centrar
public class Centrar {   
    /**
     * Centra el texto recibido en un ancho de consola de 80 caracteres (valor por defecto)
     */
    public static void texto(String texto) {
        texto(texto,80);
    }

    /**
     * Centra el texto recibido en un ancho de consola especificado en el parametro 'anchoConsola'
     */
    public static void texto(String texto, int anchoConsola) {
        int largo = texto.length();
        System.out.println (espacios((anchoConsola - largo)/2) + texto);
    }

    private static String espacios(int espacio) {
        String salida = "";
        for (int i = 0; i < espacio; i++) {
            salida = salida + " ";
        }
        return salida;
    }
} // Fin de la claseCentrar
Clase Mensa
import java.util.Scanner;

public class Mensa { // Atributos de la clase Mensa

    // Y seguidamente, procedimientos y funciones varios.
    /**
     * Mostrar el texto con salto de línea (sin segundo parámetro)
     */   
    public static 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 static void muestra (String frase, int param) {
        if (param == 0) { System.out.print (frase + " ");
        }          else { System.out.println (frase); }
    }// fin de muestra 2 parámetros

    /**
     * Sin segundo parámetro el mensaje incluirá salto de línea. Devuelve entrada de teclado
     */
    public static 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 static String responde (String frase, int param) {
        muestra (frase, param);
        Scanner entradaEscaner = new Scanner(System.in);
        return entradaEscaner.nextLine();
    }// fin de responde 2 parámetros
} // Fin de la clase Mensa
Clase Enmarcar
public class Enmarcar {         
    /**
     * @param texto String a mostrar centrado en un ancho de consola de 80 caracteres
     */
    public static void texto(String texto) {
        texto(texto, 80);
    }

    /**
     * @param texto String a mostrar centrado en un ancho de consola especificado en el siguiente parametro
     * @param anchoConsola Especifica el ancho deseado de consola
     */
    public static void texto(String texto, int anchoConsola) {
        int largo = texto.length();
        int sangria = (anchoConsola - largo)/2 - 2;
        String arriba = "_", abajo = "¯",salida = "";

        //         if (anchoConsola == 0) { sangria = 0; }
        if (sangria < 0) { sangria = 0; }
        salida =                repite(" ",sangria +1) + repite(arriba,largo+2) + "\n";
        salida = salida +       repite(" ",sangria) + "| " + texto + " |\n";
        salida = salida +  repite(" ",sangria ) +"°"  + repite(abajo,largo+2) + "°";
        System.out.println(salida);
    }

    private static String repite(String c, int n) {
        String salida = "";
        for (int i = 0; i< n; i++) {
            salida = salida + c;
        }
        return salida;
    }
} // Fin de la clase Enmarcar


Preguntas y respuestas. Diferencia entre Tipo estático y dinámico java. Ejercicio CU00690B del tutorial de programación POO de aprenderaprogramar.

a) ¿Un objeto de tipo estático declarado Taxi puede contener a un objeto Vehiculo en tiempo de ejecución?

Respuesta: SI. en tiempo de ejecución el objeto puede apuntar a un objeto de su clase padre o Superclase haciendo una conversión de tipo (casting) a la superclase

Ejemplo

Persona p1 = new Persona();
Medico m1 = new Medico()

La clase Persona es superclase de la clase Medico

La asignación m1 = p1; (poner en el objeto de una clase un objeto de la superclase)
da error.

Se puede conseguir la asignación haciendo 'casting'

m1 = (Medico) p1;

b) ¿Un objeto de tipo estático declarado Vehiculo puede contener a un objeto Taxi en tiempo de ejecución?

Respuesta: Si, siempre. Sin ningún género de duda.

c) Escribe el código de una clase Vehiculo con los atributos matricula (String) y numeroDeRuedas (int), constructor, métodos getters y setters y método toString() para mostrar la información de un vehículo.

Clase Vehiculo

public class Vehiculo {             // Atributos de la clase Vehiculo
    private String matricula;
    private int numeroDeRuedas;
    //Constructor para objetos de la clase Vehiculo
   
    public Vehiculo(String matricula, int numeroDeRuedas) {            // Inicializa atributos
        this.matricula = matricula;
        this.numeroDeRuedas = numeroDeRuedas;
    } // Fin del constructor Vehiculo
   
    // Siguen los setters para los atributos de la clase Vehiculo
    public void setMatricula (String matricula)        { this.matricula = matricula; }
    public void setNumeroDeRuedas (int numeroDeRuedas) { this.numeroDeRuedas = numeroDeRuedas; }
   
    // Ahora los getters para los atributos de la clase Vehiculo
    public String getMatricula ()                      { return matricula; }
    public int getNumeroDeRuedas ()                    { return numeroDeRuedas; }
   
    // Y seguidamente, metodos varios.
    public String toString() {
        return "       Matricula: " + matricula + "\n" +
               "Numero de ruedas: " + numeroDeRuedas + "\n";
    }
} // Fin de la clase Vehiculo

d) Escribe el código de una clase Taxi que herede de vehículo y que además de los atributos de Vehiculo lleve un atributo adicional nombreDelConductor (String) y numeroDePlazas (int), constructor, métodos getters y setters y método toString() para mostrar la información de un Taxi.

Clase Taxi

public class Taxi extends Vehiculo {             // Atributos de la clase Taxi
    private String nombreDelConductor;
    private int numeroDePlazas;
    //Constructor para objetos de la clase Taxi
    public Taxi(
   
    String matricula,
    int numeroDeRuedas,
    String nombreDelConductor,
    int numeroDePlazas) {            // Inicializa atributos
        super(matricula, numeroDeRuedas);
        this.nombreDelConductor = nombreDelConductor;
        this.numeroDePlazas = numeroDePlazas;
    } // Fin del constructor Taxi

    // Siguen los setters para los atributos de la clase Taxi
    public void setNombreDelConductor (String nombreDelConductor) { this.nombreDelConductor = nombreDelConductor; }
    public void setNumeroDePlazas (int numeroDePlazas)            { this.numeroDePlazas = numeroDePlazas; }
    // Ahora los getters para los atributos de la clase Taxi
    public String getNombreDelConductor ()                        { return nombreDelConductor; }
    public int getNumeroDePlazas ()                               { return numeroDePlazas; }
    // Y seguidamente, metodos varios.
    public String toString() {
        return super.toString() +
        "Nombre del conductor: " + nombreDelConductor + "\n" +
        "    Numero de plazas: " + numeroDePlazas;
    }
} // Fin de la clase Taxi

e) Escribe el código de una clase test con el método main que cree un objeto cuyo tipo es Vehiculo, instanciado como Taxi. Establece valores para sus atributos y usa el método toString(). ¿Qué método toString() resulta de aplicación, el propio de la clase Vehiculo o el propio de la clase Taxi? ¿Por qué?

Clase Test

public class Test { 
    public static void main (String [] args) {
        String matricula = "AS-4567";
        int numeroDeRuedas = 3;
        String nombreDelConductor = "Ramiro";
        int numeroDePlazas = 3;
        Vehiculo v1 = new Taxi(matricula,numeroDeRuedas,nombreDelConductor,numeroDePlazas);
        System.out.println ("\nEl vehiculo v1 presenta estos atributos:\n" + v1.toString());
    } // fin del main
} // Fin de la clase Test

Respuesta: Se ejecuta el método toString() del tipo contenido en el objeto (Taxi) aunque se declarara como tipo Vehiculo

Porque en tiempo de ejecución, el compilador verifica el tipo que contiene el objeto y ejecuta sus métodos, solo si no los encuentra en el tipo instanciado los busca el la clase padre.

Hola
En un archivo adjunto (ParaEnviar.rar) envío 6 clases del ejercicio +  2 clases accesorias con métodos estáticos.
Me daba error (demasiado texto para enviar) en esta ventana.

Clases:
Producto
ProductoFresco
ProductoRefrigerado
ProductoCongelado
ListaDeProductos
TestHerencia2  con main

Clases accesorias:
Validador
Mensa

Nota: En la clase ListaDeProductos hay un método convertido a comentario llamado public void muestraLista(String tipoProducto) que he sustituido por el public void muestraLista(int valor)
Este segundo método funcional recibe un entero que en un switch dirige el código
En el primer método que me daba errores, quería hacer lo mismo, pero nada, por muchas vueltas que le he dado no he sabido deshacer el entuerto.

¿Podeis hecharle un vistazo?
Y decirme, donde está la chinita o el predrusco si es el caso.

Gracias

Hola. Esta es mi respuesta al enunciado del ejercicio.

El error dado, es: Cita 1

Non-static variable this cannot be referenced from a static context

Que la variable o método no es estático y no puede referenciarse desde un contexto estático (el main)

¿Por qué lo da?: Cita 2

a) No pueden acceder a campos de instancia (lógico, pues los campos van asociados a objetos).
b) No pueden invocar a un método de instancia de la misma clase (lógico pues los métodos de instancia van asociados a objetos).

Solución:
Cambiando el método 'getAtrib1()' a estático, también es necesario cambiar a estático el atributo de la clase 'atributo1'. Y dentro del main hay que quitar el 'this' de la llamada getAtrib1()

Estos cambios los he hecho después que el compilador me diera error en cada uno de estos nombres. Y serán razones lógicas para el compilador, pero para mí están ocultas.
Pues, si no se puede (ver Cita 2), ¿como es que después de añadir 'static' se si puede acceder a campos y métodos de la instancia?

Entiendo más el porqué, viendo el ERROR (ver Cita 1) que da el compilador, si hacemos los atributos y métodos estáticos se podrán llamar desde el main (estático).
Es como si al ser todos estáticos, se pudieran comunicar entre ellos.

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.

Preguntas y respuestas CU00677B

Busca información en la documentación oficial de Java sobre la interface Iterable. ¿Qué clases de las
que conoces implementan esta interface? ¿Qué método han de tener disponible las clases que
implementan esta interface? ¿Para qué sirve este método?

Respuesta:
La interface Iterable está implementada en las clases:
ArrayList (usada en los ejemplos prácticos)
LinkedList y Stack (otras clases para manipular colecciones)
entre otras muchas.

Estas clases han de disponer del método 'iterator()' (Al parecer, el único método en esta interface)
El método iterator() como se dice en la documentación del interface Iterable, es permitir que un objeto sea el destino en un for extendido
-------------------------
Ejercicio CU00678B
Clase EjercicioPolimorfismo
import java.util.*;

/**
 * Detalles de la clase.
 * @author (Toni)
 * @version (0)
 */
public class EjercicioPolimorfismo {           
    public static void main (String [] args) {
        // Declaración del ArrayList
        ArrayList<Set> planetasYCifras = new ArrayList<Set>();
        String [] planetasArr = {"sol", "luna", "saturno"};
        // 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};
        // 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 ("\n\tElementos del HashSet ");
                Iterator<HashSet> itHS = tmpSet.iterator();
                while (itHS.hasNext()) {
                    if (tmpObj != null) { System.out.print (", "); }
                    tmpObj = itHS.next();
                    System.out.print (tmpObj );
                }
                System.out.print (".");
            } else if (tmpSet instanceof java.util.TreeSet) {
                System.out.println ("\n\tElementos del TreeSet ");
                TreeSet ts = (TreeSet) tmpSet; // conversión de tipo para usar descendingIterator
                Iterator<TreeSet> itTS = ts.descendingIterator();
                while (itTS.hasNext()) {
                    if (tmpObj != null) { System.out.print (", "); }
                    tmpObj = itTS.next();
                    System.out.print (tmpObj );
                }
                System.out.print (".");
            }
        } // fin del while itPYC
    } // fin del main
} // Fin de la clase EjercicioPolimorfismoEste ejercicio me ha hecho bucear en la documentación de las clases java.
He probado varias maneras de llegar al final, todas erróneas hasta conseguirlo.
Espero no haber dado demasiadas vueltas para conseguir las cuatro líneas que da el programa al ejecutarse.

Espero vuestros 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


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.