Ejercicio resuelto: interfaces, default y múltiples implementaciones en Java

La solución separa dos contratos independientes. Figura describe lo que toda figura sabe hacer (calcular su área y dar su nombre) y aporta, mediante un método default, un comportamiento común construido a partir de esos dos métodos. Lados es un contrato opcional: solo lo firman las figuras poligonales.

Las clases Rectangulo, Cuadrado y Triangulo implementan ambas interfaces a la vez (implementación múltiple), mientras que Circulo implementa solo Figura. El programa principal trabaja siempre con el tipo Figura y consulta el contrato adicional con instanceof.

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Scanner;

interface Figura {
    double area();

    String nombre();

    default String describe() {
        return nombre() + " area=" + String.format(Locale.ROOT, "%.2f", area());
    }
}

interface Lados {
    int numLados();
}

class Circulo implements Figura {
    private final double radio;

    Circulo(double radio) {
        this.radio = radio;
    }

    public double area() {
        return Math.PI * radio * radio;
    }

    public String nombre() {
        return "Circulo";
    }
}

class Rectangulo implements Figura, Lados {
    private final double base;
    private final double altura;

    Rectangulo(double base, double altura) {
        this.base = base;
        this.altura = altura;
    }

    public double area() {
        return base * altura;
    }

    public String nombre() {
        return "Rectangulo";
    }

    public int numLados() {
        return 4;
    }
}

class Cuadrado implements Figura, Lados {
    private final double lado;

    Cuadrado(double lado) {
        this.lado = lado;
    }

    public double area() {
        return lado * lado;
    }

    public String nombre() {
        return "Cuadrado";
    }

    public int numLados() {
        return 4;
    }
}

class Triangulo implements Figura, Lados {
    private final double base;
    private final double altura;

    Triangulo(double base, double altura) {
        this.base = base;
        this.altura = altura;
    }

    public double area() {
        return base * altura / 2;
    }

    public String nombre() {
        return "Triangulo";
    }

    public int numLados() {
        return 3;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        sc.useLocale(Locale.ROOT);
        int n = sc.hasNextInt() ? sc.nextInt() : 0;
        List<Figura> figuras = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            String tipo = sc.next();
            switch (tipo) {
                case "C" -> figuras.add(new Circulo(sc.nextDouble()));
                case "R" -> figuras.add(new Rectangulo(sc.nextDouble(), sc.nextDouble()));
                case "Q" -> figuras.add(new Cuadrado(sc.nextDouble()));
                case "T" -> figuras.add(new Triangulo(sc.nextDouble(), sc.nextDouble()));
                default -> throw new IllegalArgumentException("Tipo desconocido: " + tipo);
            }
        }
        double total = 0;
        int conLados = 0;
        for (Figura f : figuras) {
            StringBuilder linea = new StringBuilder(f.describe());
            if (f instanceof Lados l) {
                linea.append(" lados=").append(l.numLados());
                conLados++;
            }
            System.out.println(linea);
            total += f.area();
        }
        System.out.println("total=" + String.format(Locale.ROOT, "%.2f", total) + " conLados=" + conLados);
    }
}

La interfaz Figura contiene dos métodos abstractos y el método default describe(). Dentro de describe() se llama a nombre() y area(), que se resuelven dinámicamente según la clase concreta del objeto. Así el formato de la línea (nombre, espacio, area=, dos decimales) está escrito en un único sitio, y ninguna de las cuatro clases lo repite ni lo sobrescribe.

Lados es una interfaz de un solo método. Rectangulo, Cuadrado y Triangulo declaran implements Figura, Lados; Circulo declara solo implements Figura. Esto modela fielmente el dominio: tener lados es una capacidad que unas figuras tienen y otras no, y por eso no se mete numLados() en Figura devolviendo 0 para el círculo. Los métodos implementados de una interfaz deben ser public, razón por la que aparece esa palabra en cada uno.

En main se lee n y se construye una List<Figura> con un switch sobre la palabra clave. El escáner usa Locale.ROOT para leer los decimales con punto. Se trabaja siempre con el tipo Figura: es polimorfismo puro, y el resto del programa no sabe qué clase concreta tiene delante.

En el bucle de salida, f.describe() da la línea base. Después, f instanceof Lados l comprueba si el objeto también cumple el segundo contrato y, en caso afirmativo, introduce la variable l ya convertida, sin cast explícito. Se añade lados= con l.numLados() y se incrementa conLados. La variable total acumula el área sin redondear, y solo se formatea al imprimir la última línea.

Con los casos de prueba: la lista vacía imprime únicamente total=0.00 conLados=0; un círculo solo imprime una línea sin lados= y conLados=0; el caso mixto comprueba que los tres tipos poligonales informan 4, 4 y 3 lados y que el círculo no los informa. El caso de acumulación de decimales verifica que se suma sin redondear antes de formatear.