← Volver a actividades
Autoevaluación

Autoevaluación: Manejo de Excepciones, Jerarquía Throwable y Robustez

Manejo de Excepciones y Robustez

Respondé todas las preguntas y presioná Calificar para ver tu puntaje.

1. Observá estas dos excepciones y los métodos que las lanzan. ¿Qué diferencia hay entre ellos para el compilador?
class ArchivoNoEncontradoException extends Exception { }
class EdadInvalidaException extends RuntimeException { }

static void a() {
    throw new ArchivoNoEncontradoException();
}

static void b() {
    throw new EdadInvalidaException();
}
Correcto Incorrecto Sin responder

Respuesta correcta: a() no compila: la excepción es checked y exige try-catch o throws; b() compila porque la excepción es unchecked (hereda de RuntimeException).

¿Por qué? Las checked exceptions representan condiciones de error recuperables del entorno (como archivos no encontrados o fallas de red) y el compilador exige gestionarlas. Las unchecked (hijas de RuntimeException) suelen representar errores de programación o violación de precondiciones (como NullPointerException o IllegalArgumentException).

2. Observá el método. Al llamar a leer(), se imprime cierre aunque el try ejecute un return.
static int leer() {
    try {
        return 1;
    } finally {
        System.out.println("cierre");
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Verdadero

¿Por qué? Verdadero. La garantía fundamental de finally es ejecutarse siempre antes de salir del ámbito del método, lo que lo hace el lugar idóneo para liberar recursos, cerrar conexiones o emitir registros de auditoría.

3. Observá el código. ¿Por qué es una mala idea el catch (Error e) en este caso?
try {
    recursivo(1);
} catch (Error e) {
    System.out.println("Seguimos como si nada");
}

static void recursivo(int n) {
    recursivo(n + 1);   // sin caso base
}
Correcto Incorrecto Sin responder

Respuesta correcta: Porque el desbordamiento de pila (StackOverflowError) es una falla grave de la JVM: la aplicación no puede garantizar un estado consistente después de atraparlo.

¿Por qué? La recursión sin caso base lanza StackOverflowError, un Error: indica un problema grave de la JVM (pila agotada). Atraparlo y seguir ejecutando es un antipatrón peligroso porque el estado interno ya no es confiable. Lo correcto es arreglar la causa, en este caso agregar un caso base.

4. Observá el método. Según este código, throws (en la firma) instancia y lanza la excepción, mientras que throw (en el cuerpo) declara qué excepciones pueden propagarse al llamador.
static void validar(int n) throws IllegalArgumentException {
    if (n < 0) {
        throw new IllegalArgumentException("negativo");
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Falso

¿Por qué? Falso. Es exactamente al revés: throw (en singular) se usa dentro del cuerpo del método para lanzar una instancia concreta (throw new MiExcepcion();), mientras que throws (en plural) se utiliza en la firma del método para declarar las excepciones checked que pueden escapar (void metodo() throws IOException).

5. Observá la cadena de llamadas. ¿Qué ocurre al ejecutar main?
static void a() {
    b();
    System.out.println("fin a");
}
static void b() {
    c();
    System.out.println("fin b");
}
static void c() {
    throw new IllegalStateException("falla");
}
public static void main(String[] args) {
    a();
    System.out.println("fin main");
}
Correcto Incorrecto Sin responder

Respuesta correcta: La excepción sube por c, b, a y main sin que nadie la capture: no se imprime ningún "fin" y el hilo termina con el stack trace.

¿Por qué? Ningún método tiene catch, así que la excepción se propaga hacia atrás por los frames de la pila (c → b → a → main). Cada método queda abandonado inmediatamente, por eso las líneas que siguen a cada llamada nunca se ejecutan. Al llegar a la base sin ser capturada, el hilo termina y la JVM muestra el stack trace.

6. ¿Por qué dejar un bloque catch completamente vacío (swallowing exception) se considera uno de los peores antipatrones de programación?
try {
    procesarArchivo();
} catch (Exception e) {
    // vacío
}
Correcto Incorrecto Sin responder

Respuesta correcta: Porque silencia la falla por completo, ocultando la causa raíz del problema y dejando la aplicación en un estado inconsistente sin que nadie sepa que algo falló.

¿Por qué? "Tragarse" excepciones destruye la visibilidad de los errores: el programa continúa como si nada hubiera ocurrido, pero con datos corruptos o transacciones a medio hacer, volviendo la depuración casi imposible.

7. Observá la clase. Esta excepción personalizada es válida: además del mensaje heredado de Throwable, transporta un atributo de dominio propio (montoSolicitado).
class SaldoInsuficienteException extends Exception {
    private final double montoSolicitado;

    public SaldoInsuficienteException(String mensaje, double montoSolicitado) {
        super(mensaje);
        this.montoSolicitado = montoSolicitado;
    }

    public double getMontoSolicitado() {
        return montoSolicitado;
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Verdadero

¿Por qué? Verdadero. Al ser una clase Java estándar, una excepción propia puede y debe enriquecerse con campos inmutables y métodos que provean información contextual valiosa para el registro y manejo del error.

8. Observá el código. ¿Qué método de Throwable falta en el catch interno para recuperar la excepción original (SQLException) que provocó RepositorioException?
try {
    try {
        repo.buscar(id);
    } catch (SQLException e) {
        throw new RepositorioException("No se pudo consultar", e);
    }
} catch (RepositorioException e) {
    Throwable original = e.______();
}
Correcto Incorrecto Sin responder

Respuesta correcta: getCause()

¿Por qué? getCause() devuelve el Throwable original que fue pasado como causa al construir la excepción actual (por ejemplo, new MiExcepcion("Fallo en servicio", sqlException)), preservando la cadena diagnóstica completa.

9. Observá el código. Recorrer el array hasta que salte ArrayIndexOutOfBoundsException para terminar el bucle es una práctica recomendada y de alto rendimiento.
int[] arr = {10, 20, 30};
int i = 0;
try {
    while (true) {
        System.out.println(arr[i]);
        i++;
    }
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("fin");
}
Correcto Incorrecto Sin responder

Respuesta correcta: Falso

¿Por qué? Falso. Las excepciones están pensadas para situaciones anómalas. Crear y propagar excepciones implica capturar el Stack Trace de la pila de llamadas, lo que conlleva un coste de procesamiento significativo; jamás deben usarse para sustituir condiciones booleanas normales de parada en bucles.

10. Observá el orden de los bloques catch. ¿Qué ocurre al compilar?
static void abrir() throws IOException { ... }

try {
    abrir();
} catch (Exception e) {
    System.out.println("Error general");
} catch (IOException e) {
    System.out.println("Error de entrada/salida");
}
Correcto Incorrecto Sin responder

Respuesta correcta: Error de compilación: el catch (IOException e) es inalcanzable porque Exception ya atrapa todas sus subclases; hay que ordenar de la más específica a la más general.

¿Por qué? Java evalúa los catch de arriba hacia abajo. catch (Exception e) en primer lugar atrapa todas las excepciones hijas, por lo que el catch (IOException e) nunca podría ejecutarse y el compilador lo rechaza como código inalcanzable. Se debe invertir el orden: primero IOException, después Exception.

11. Un programa pide un número con Scanner y el usuario escribe abc. ¿Qué excepción lanza leer.nextInt() y de qué tipo es?
Scanner leer = new Scanner(System.in);
int nroUno = leer.nextInt();   // el usuario escribe: abc
Correcto Incorrecto Sin responder

Respuesta correcta: InputMismatchException, una excepción unchecked (hereda de RuntimeException), por lo que el compilador no obliga a capturarla.

¿Por qué? Scanner.nextInt() lanza InputMismatchException cuando el siguiente texto no tiene formato de entero. Es unchecked: el compilador no te obliga a manejarla, pero un programa robusto debe prever que el usuario puede escribir cualquier cosa. NumberFormatException es la que lanza Integer.parseInt, no Scanner.

12. En este código, el catch (ArithmeticException e) nunca se ejecuta aunque el usuario ingrese 0 como segundo número, porque la división es entre un int y un double y el resultado es Infinity.
try {
    int nroUno = leer.nextInt();
    double nroDos = leer.nextInt();
    double resultado = nroUno / nroDos;
    System.out.println("El resultado es: " + resultado);
} catch (ArithmeticException e) {
    System.out.println("No se puede dividir por ZERO!");
}
Correcto Incorrecto Sin responder

Respuesta correcta: Verdadero

¿Por qué? Verdadero. ArithmeticException solo se lanza en la división entera por cero (int / int). Cuando algún operando es double, la división sigue la aritmética de punto flotante y devuelve Infinity (o NaN en 0.0 / 0.0) sin lanzar nada. Moraleja: un catch solo sirve si el código del try realmente puede lanzar esa excepción.

13. En este código con try anidados, el usuario escribe hola como primer número. ¿Qué se imprime?
int nroUno = 0;
int nroDos = 0;
try {
    try {
        nroUno = leer.nextInt();
        nroDos = leer.nextInt();
    } catch (Exception e) {
        System.out.println("Solo se admiten números");
    }
    System.out.println(nroUno / nroDos);
} catch (ArithmeticException e) {
    System.out.println("No pudimos dividir: " + e.getMessage());
}
System.out.println("Fin del programa");
Correcto Incorrecto Sin responder

Respuesta correcta: Solo se admiten números / No pudimos dividir: / by zero / Fin del programa

¿Por qué? El catch (Exception e) interno atrapa la InputMismatchException y el flujo continúa después del try interno. Pero como nroUno y nroDos quedaron en 0, la división 0 / 0 lanza ArithmeticException con mensaje / by zero, que atrapa el catch externo. Atrapar una excepción no "arregla" el estado: acá los datos quedaron inválidos y el error reaparece más abajo.

14. Observá los bloques catch. Este orden es válido: el último catch (Exception e) actúa como red de seguridad para cualquier excepción que no se haya previsto.
try {
    int numero = leer.nextInt();
    System.out.println(100 / numero);
} catch (InputMismatchException e) {
    System.out.println("Debés ingresar un número");
} catch (ArithmeticException e) {
    System.out.println("No se puede dividir por cero");
} catch (Exception e) {
    System.out.println("Algo salió mal: " + e.getMessage());
}
Correcto Incorrecto Sin responder

Respuesta correcta: Verdadero

¿Por qué? Verdadero. Los catch se evalúan en orden, y mientras las clases específicas (que no se heredan entre sí) estén antes que la general Exception, el código compila. El catch (Exception e) final atrapa lo imprevisto. Eso sí: úsalo para informar o registrar el error, nunca vacío.

15. Se define una excepción propia y un método que la declara. ¿Qué ocurre al compilar main?
class LongitudDelNumero extends Exception {
    public LongitudDelNumero(String mensaje) { super(mensaje); }
}

static void evaluarNumero(int n) throws LongitudDelNumero {
    if (n < 100) throw new LongitudDelNumero("Número inferior a 100");
}

public static void main(String[] args) {
    evaluarNumero(50);
}
Correcto Incorrecto Sin responder

Respuesta correcta: Error de compilación: la excepción es checked y main debe capturarla con try-catch o declararla con throws.

¿Por qué? Al extender Exception (sin ser RuntimeException), LongitudDelNumero es checked. El compilador exige que quien llama a evaluarNumero la maneje o la propague. Si hubiera extendido RuntimeException, el código compilaría sin ese requisito.

16. Observá la clase. Esta excepción propia es unchecked, porque la creó el programador y no pertenece a la biblioteca estándar.
class NumeroPequenio extends IOException {
    public NumeroPequenio(String mensajeError) {
        super(mensajeError);
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Falso

¿Por qué? Falso. Que una excepción sea checked o unchecked depende de su herencia, no de quién la escribió: IOException es checked, así que todas sus subclases también lo son. Además, extender IOException para un error que no tiene que ver con entrada/salida confunde el diseño; conviene extender Exception (checked) o RuntimeException (unchecked) según corresponda.

17. Este código intenta dividir por cero pero el único catch es de otro tipo. ¿Qué pasa?
try {
    int resultado = 10 / 0;
} catch (InputMismatchException e) {
    System.out.println("Texto inválido");
} finally {
    System.out.println("Limpieza");
}
System.out.println("Fin del programa");
Correcto Incorrecto Sin responder

Respuesta correcta: Imprime Limpieza, y luego la ArithmeticException sigue propagándose: el programa termina con un stack trace y nunca llega a Fin del programa.

¿Por qué? Ningún catch coincide con ArithmeticException, así que la excepción no queda atrapada. Aun así, finally se ejecuta siempre antes de abandonar el bloque, e imprime Limpieza. Después la excepción sigue subiendo por la pila, y como nadie la captura el hilo termina con el stack trace. finally limpia, pero no atrapa.

18. Observá el código. El FileWriter se cierra automáticamente al terminar el bloque, haya ocurrido una excepción o no, sin llamar a writer.close() ni usar un finally.
try (FileWriter writer = new FileWriter(ruta)) {
    writer.write("Hola, este es un archivo de prueba.");
} catch (IOException e) {
    System.out.println("Ocurrió un error al escribir en el archivo.");
}
Correcto Incorrecto Sin responder

Respuesta correcta: Verdadero

¿Por qué? Verdadero. Es try-with-resources: todo recurso que implemente AutoCloseable y se declare entre los paréntesis del try se cierra solo. Además, FileWriter lanza IOException (checked) si la ruta no es válida, por ejemplo si el directorio no existe, así que igualmente hace falta un catch (IOException e) o un throws.

19. Un programa repite la lectura de un número dentro de un while y, ante una InputMismatchException, ejecuta leer.nextLine() dentro del catch. ¿Para qué sirve esa llamada?
while (seguir) {
    try {
        int nroUno = leer.nextInt();
        seguir = false;
    } catch (InputMismatchException e) {
        System.out.println("Error al ingresar los datos");
        leer.nextLine();
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Para descartar el texto inválido que quedó en el buffer del Scanner; sin eso, el siguiente nextInt() lo vuelve a leer, falla otra vez y el bucle no termina nunca.

¿Por qué? Cuando nextInt() falla, el token inválido no se consume: sigue en el buffer. Si no se descarta con nextLine(), cada reintento lee lo mismo y lanza la misma excepción, generando un bucle infinito. Es el patrón clásico para validar entrada con reintento.

20. Observá el método. Para compilar, validarDni debería declarar throws IllegalArgumentException en su firma.
static void validarDni(int dni) {
    if (dni <= 0) {
        throw new IllegalArgumentException("El DNI debe ser positivo");
    }
}
Correcto Incorrecto Sin responder

Respuesta correcta: Falso

¿Por qué? Falso. IllegalArgumentException es unchecked (hereda de RuntimeException), por lo que el compilador no exige throws ni try-catch. En cambio, un método que lance una excepción propia que extiende Exception (como MenorDeEdadException) sí debe declararla con throws o capturarla dentro.