Ejercicio 2: Propagación de Excepciones

Enunciado

En tu programa de la calculadora, o en el ejercicio anterior, crea un método que realice la división y que sea invocado desde otro método (por ejemplo, desde el método main).

Añade el código necesario para propagar las excepciones que puedan producirse en el método de división. Captúralas en el método que invoca al método de división (por ejemplo, en el main).

Prueba indicar que el método de la división también pueda lanzar la excepción IOException. ¿Qué ocurre ahora? ¿Por qué no ocurría con ArithmeticException?

Solución

En este ejercicio vemos cómo propagar excepciones utilizando la palabra reservada throws en la firma del método. Esto delega la responsabilidad de manejar el error al método que hace la llamada (en este caso, el main).

package Tema7.Ejercicios.ejercicio2;

import java.io.IOException;

public class Ejercicio2 {

    public static void main(String[] args) {
        try {
            // El método main invoca a dividir y se hace cargo de las posibles excepciones
            double resultado = dividir(10, 0);
            System.out.println("Resultado: " + resultado);

        } catch (ArithmeticException e) {
            System.err.println("Error capturado en main: No se puede dividir por cero.");
        } catch (IOException e) {
            System.err.println("Error capturado en main: Ocurrió una excepción de entrada/salida.");
        } finally {
            System.out.println("Finalizando la ejecución del programa.");
        }
    }

    // El método delega la gestión de errores hacia arriba con "throws IOException"
    public static double dividir(int a, int b) throws IOException {
        if (b == 0) {
            throw new ArithmeticException();
        }
        return (double) a / b;
    }
}

Respuestas a las preguntas teóricas

¿Qué ocurre al añadir throws IOException?

Al añadir esta cláusula a la firma del método dividir, el compilador de Java nos obliga inmediatamente a que el método main (quien lo invoca) tenga que capturar esa excepción con un bloque catch (IOException e) o que, a su vez, vuelva a propagarla añadiendo otro throws en la firma del main.

¿Por qué no ocurría con ArithmeticException?

Esta es una de las diferencias más importantes en Java:

• ArithmeticException es una excepción No Verificada (Unchecked) porque hereda de RuntimeException. Java asume que es un error de lógica del programador y no te obliga en tiempo de compilación a capturarla o propagarla.
• IOException es una excepción Verificada (Checked) porque hereda directamente de Exception. Java considera que es un fallo externo (como problemas al leer un disco) y, por tanto, el compilador te exige de forma estricta que lo gestiones explícitamente para asegurar la estabilidad del programa.