Ejercicio CU00694B sobreescribir métodos Java comparacion identidad e igualdad

[toni_apr]

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

Código: [Seleccionar]

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

Código: [Seleccionar]

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

Código: [Seleccionar]

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

Código: [Seleccionar]

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

Código: [Seleccionar]

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

Código: [Seleccionar]

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

Código: [Seleccionar]

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


[dongo]

Esta bien, como en ejercicios anteriores, ofreces un 200% mas de lo que se pide, y eso esta muy bien, aun así te haré un par de puntualizaciones:

- La primera, es que la próxima vez aparte de adjuntar el código, para que  se pueda repasar directamente, intenta adjuntar también los ficheros, así nos costara menos probarlo .

- La segunda es recomendarte el uso de anotaciones, en java, existe una serie de anotaciones para indicar que es lo que  viene a continuación. En este caso te enseñaré la anotación @Override esta anotación se usa para indicar que un método será sobrescrito, se escribe justo antes del método que será sobrescrito( ver ejemplo).

Código: [Seleccionar]

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();
    }
    @Override
    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 Circulo

Si te fijas, justo antes de la definición del método equals, e añadido la anotación @Override, esto simplemente es como una aclaración de que ese será un método sobrescrito de la clase padre. 

Por cierto, veo que ya vas metiendo comentarios para los javadoc, esta bien eso, para que vayas aprendiendo.

Y bueno no se si alguien tendrá algo más que decir... De momento esto que te comento es lo que he visto, esta currado, funciona bien y separas las distintas funciones. Muy bien, a ver si empiezas ya con cositas que den mas juego... ficheros, bases de datos, ....

Bueno un saludo y a seguir para adelante. 
 

[toni_apr]

Hola dongo. Gracias por tus comentarios.

Cuando el ejercicio incluya muchas clases, haré lo que me dices. Poner también en un adjunto los ficheros.

Y en cuanto al uso del comentario '@Override': OK, ningún problema, lo voy a usar cada vez que sobreescriba un método de la clase padre.
He leido que si no se pone, la compilación va igual, pero que al programador le sirve de banderita diciendo (¡he, este método se sobreescribe de la clase padre!) y hace más facil seguir el código.

Gracias otra vez y Salud.

[ZSCFCP]

Buenos días.

Precioso el manejo en la salida del ejercicio de Toni. Enhorabuena. Despues de ver esto cuesta publicar el mio jejeje.

Aun así, lo adjunto por si no esté haciendo bien algo o no interpretando del todo bien los conceptos. Ahí va:

Clase FIGURA:

Código: [Seleccionar]

package CU00694B;

/**
 * Clase Figura.
 *
 * @author ZSCFCP
 * @version 20141125.1.0
 */
public class Figura
{
    protected final Double PI = 3.1416;
    protected Double dimensionPrincipal;

    /** Constructor sin parámetros.  */
    public Figura() { this(0.0d); }
    /** Constructor con parámetros.  */
    public Figura(Double dimensionPrincipal) { this.dimensionPrincipal = dimensionPrincipal; }

    /** Métodos getter y setters */
    public void setDimensionPrincipal(Double dimensionPrincipal) { this.dimensionPrincipal = dimensionPrincipal; }
    public Double getDimensionPrincipal() { return dimensionPrincipal; }
    /** Otros métodos. */
    @Override
    public String toString() {
        return "Dimensión principal = ".concat(dimensionPrincipal.toString());
    }
    public void mostrarDatos() {System.out.println(toString());}       
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Figura) {
            Figura tmpFig = (Figura) obj;
            if (this.dimensionPrincipal.equals(tmpFig.dimensionPrincipal)) {return true;} else {return false;}
        } else {return false;}
    }
}


Clase CUADRADO:

Código: [Seleccionar]

package CU00694B;

/**
 * Clase Cuadrado.
 *
 * @author ZSCFCP
 * @version 2015112.1.0
 */
public class Cuadrado extends Figura
{
    private Double areaCuadrado;
    /** Constructor for objects of class Cuadrado (sin parametros)   */
    public Cuadrado()   { super(0d); areaCuadrado=0d;}
    /** Constructor for objects of class Cuadrado (con parametros)   */
    public Cuadrado(Double dimensionPrincipal)   { super(dimensionPrincipal); calcularArea(); }

    /**
     * Método para calcular el área del cuadrado a partir del valor del lado proporcionado.
     * @return     devuelve un double con el valor del área del cuadrado.
     */
    public void calcularArea()
    {
        areaCuadrado = dimensionPrincipal * dimensionPrincipal;
    }
   
    @Override
    public String toString() {
        return super.toString().concat(" / Área del cuadrado = ").concat(areaCuadrado.toString());
    }   
   
    public void mostrarDatos() {super.mostrarDatos();}
   
    public boolean equals(Object obj)
    {
        if (obj instanceof Cuadrado) {
             Cuadrado tmpCuadrado = (Cuadrado) obj;
            if (super.equals(tmpCuadrado) && this.areaCuadrado.equals(tmpCuadrado.areaCuadrado)) { return true; } else { return false; }
        } else { return false; } 
    }
}


Clase CIRCULO:

Código: [Seleccionar]

package CU00694B;

/**
 * Clase Circulo.
 *
 * @author ZSCFCP
 * @version 2015112.1.0
 */
public class Circulo extends Figura
{
    private Double areaCirculo;
    /** Constructor for objects of class Circulo (sin parametros)   */
    public Circulo()   { super(0d); areaCirculo=0d;}
    /** Constructor for objects of class Circulo (con parametros)   */
    public Circulo(Double dimensionPrincipal)   { super(dimensionPrincipal); calcularArea(); }

    /**
     * Método para calcular el área del circulo a partir del valor del radio proporcionado.
     * @return     devuelve un double con el valor del área del circulo.
     */
    public void calcularArea()
    {
        areaCirculo = PI * dimensionPrincipal * dimensionPrincipal;
    }
   
    @Override
    public String toString() {
        return super.toString().concat(" / Área del círculo = ").concat(areaCirculo.toString());
    } 
   
    public void mostrarDatos() {super.mostrarDatos();}
   
    @Override
    public boolean equals(Object obj)
    {
        if (obj instanceof Circulo) {
             Circulo tmpCirculo = (Circulo) obj;
            if (super.equals(tmpCirculo) && this.areaCirculo.equals(tmpCirculo.areaCirculo)) { return true; } else { return false; }
        } else { return false; } 
    }
}


Clase LISTAFIGURAS (esta no esta prevista en el enunciado pero lleno e itero en la siguiente un ArrayList de figuras):

Código: [Seleccionar]

package CU00694B;

import java.util.ArrayList;
import java.util.List;

public class ListaFiguras{
    private List<Figura> listaFiguras;
//Constructor
    public ListaFiguras () {
        listaFiguras = new ArrayList <Figura> ();
    }
//Métodos
    public void addFigura (Figura figura) { listaFiguras.add(figura); } 
    public List<Figura> viewListaFiguras()     { return listaFiguras; }
} //Cierre de la clase


y por ultimo la clase TEST:

Código: [Seleccionar]

package CU00694B;

import java.util.Iterator;

/**
 * Clase TEST del ejercicio CU00694B para probar la sobreescritura de metodos toString() y equals().
 *
 * @author ZSCFCP
 * @version 20141126.1.0
 */
public class Test
{
    public static void main (String [ ] Args)
    {
        ListaFiguras listFig1 = new ListaFiguras();
       
        Cuadrado cuad1 = new Cuadrado(5.0d);
        Cuadrado cuad2 = new Cuadrado(10.0d);
        Cuadrado cuad3 = new Cuadrado(5.0d);
       
        Circulo  circ1 = new Circulo(6.0d);
        Circulo  circ2 = new Circulo(10.d);
        Circulo  circ3 = new Circulo(6.0d);
       
        Figura   figu1 = new Figura(5.0d);
        Figura   figu2 = new Figura(6.0d);
        Figura   figu3 = new Figura(7.0d);
       
        listFig1.addFigura(cuad1); listFig1.addFigura(cuad2); listFig1.addFigura(cuad3);
        listFig1.addFigura(circ1); listFig1.addFigura(circ2); listFig1.addFigura(circ3);
        listFig1.addFigura(figu1); listFig1.addFigura(figu2); listFig1.addFigura(figu3);
       
        Iterator<Figura> it = listFig1.viewListaFiguras().iterator();
        Figura tmpFig=null;
        String cabecera=null;
        String separador="________________________________________________________________\n";
        System.out.println(separador);
        System.out.println("   Las figuras que constan son las siguientes: ");
        System.out.println(separador);
        while (it.hasNext())
        {
            tmpFig = it.next();
            if (tmpFig instanceof Circulo) {cabecera="CIRCULO";}
            else {if (tmpFig instanceof Cuadrado) {cabecera="CUADRADO";}
                  else {if (tmpFig instanceof Figura) {cabecera="FIGURA";}}}
            System.out.println("Objeto: \"" + cabecera + "\"");
            tmpFig.mostrarDatos();
            System.out.println(separador);           
        }
           
        System.out.println ("¿Son iguales los cuadrados cuad1 y cuad2?: " + cuad1.equals(cuad2) );
        System.out.println ("¿Son iguales los cuadrados cuad1 y cuad3?: " + cuad1.equals(cuad3) );       
        System.out.println ("¿Son iguales los circulos  circ1 y circ2?: " + circ1.equals(circ2) );       
        System.out.println ("¿Son iguales los circulos  circ1 y circ3?: " + circ1.equals(circ3) );
        System.out.println ("¿Son iguales las figuras   figu1 y figu2?: " + figu1.equals(figu2) );             
        System.out.println ("¿Son iguales las figuras   figu1 y figu3?: " + figu1.equals(figu3) );                     
        System.out.println ("¿Son iguales cuad1 y circ3?: " + cuad1.equals(circ3) );   
        System.out.println ("¿Son iguales cuad1 y figu1?: " + cuad1.equals(figu1) );       
        System.out.println ("¿Son iguales circ1 y figu2?: " + circ1.equals(figu2) );     
       
    }
}

Gracias y saludos.

[javi in the sky]

Hola ZSCFCP he revisado el código y te hago algunas indicaciones:


En la clase figura tienes el constructor sin parámetros public Figura() { this(0.0d); }, está bien planteado. La d creo que podrías quitarla (aquí y en otros lugares).

Veo que estás usando private Double areaCirculo; con Double tipo objeto (wrapper) en lugar de tipo primitivo. ¿Algún motivo para no usar el tipo primitivo?

Este método lo veo poco interesante: public void mostrarDatos() {System.out.println(toString());}

¿Qué es lo que aporta si simplemente llama a toString() ?



En la clase Cuadrado y en la clase círculo la definición de equals aparte de comprobar que tengan la misma dimensión también compruebas el área. Pero creo que comprobar el área no es realmente necesario. Si tienen la misma dimensión principal, tienen que tener el mismo área, por tanto hay tienes una comprobación que no es útil.



En la clase ListaFiguras estás haciendo un buen uso del polimorfismo al declarar listaFiguras como tipo List y luego implementarlo como tipo ArrayList.

Sin embargo en la clase test no has hecho uso del polimorfismo. Hubieras aprovechado esta característica si declaras:

Figura cuad1 = new Cuadrado(5.0d);
Figura cuad2 = new Cuadrado(10.0d);
Figura cuad3 = new Cuadrado(5.0d);
       
Figura  circ1 = new Circulo(6.0d);
Figura  circ2 = new Circulo(10.d);
Figura  circ3 = new Circulo(6.0d);

En general se ve que manejas bien los conceptos, enhorabuena!!!