Software

En PC Resumen vamos a hablar del funcionamiento de la sentencia throws en Java. Si un método es capaz de causar una excepción que él mismo no puede manejar, debe especificarse el comportamiento de forma que los métodos que llamen a este método puedan protegerse de la excepción. Para hacerlo debe incluir una cláusula throws a la declaración del método. Esta cláusula da un listado de los tipos de excepciones que puede tirar. Si no se declara se provoca un error en tiempo de compilación. La lista de excepciones debe ir separada por comas.

Fijémonos en el siguiente código:

import java.util.InputMismatchException;
import java.util.Scanner;

class DivisionEntreZeroAmbtractamentExcepcions {
    public static int cociente(int numerador, int denominador) throws ArithmeticException {
        return numerador / denominador; // posible división por cero
    }
    
    public static void main(String args[]) {
        Scanner explorador = new Scanner(System.in); // objeto Scanner para la entrada
        boolean continuar = true; // determina si se necesitan más datos de entrada
        do {
            try {
                System.out.print("Introduce un numerador entero: ");
                int numerador = explorador.nextInt();
                System.out.print ("Introduce un denominador entero: ");
                int denominador = explorador.nextInt();
                int resultado = cociente(numerador, denominador);
                System.out.printf ("\nResultado: %d / %d =% d\n", numerador, denominador, resultado);
                continuar = false; // entrada exitosa;
            } catch (InputMismatchException inputMismatchException) {
                System.err.printf("\nExcepción: %s \n",
                inputMismatchException);
                explorador.nextLine(); // descarta entrada para probar de nuevo
                System.out.println ("Introduce enteros. \n");
            } // fin de bloque catch
            catch (ArithmeticException arithmeticException) {
                System.err.printf ("\nExcepción: %s \n", arithmeticException);
                System.out.println ("Zero no es un denominador válido. \n");
            }
        } While (continuar);
    }
}

En el método cociente ponemos throws ArithmeticException. Esta cláusula especifica la excepción que tira el método. La cláusula aparece después de la lista de parámetros del método y antes de su cuerpo.

Un método puede lanzar excepciones de las clases que se listen en la cláusula throws o en la de sus subclases. Hemos puesto esta cláusula para indicar al resto del programa que este método puede lanzar una excepción ArithmeticException. De este modo los usuarios de este método se les informa que este método puede lanzar la excepción.

Se debe entender que cuando cociente tira la excepción el método termina, no devuelve nada y las variables locales quedan fuera del alcance y se destruyen. Si este método contiene variables locales que sean referencias a objetos y no hay otras referencias a estos objetos, estos se marcan para la recolección de basura.

• Sabiendo que un método podrá tirar una excepción, es recomendable incluir el código apropiado para manejar las excepciones en nuestro programa, para que sea más robusto.
• Hay que leer la documentación de la API para saber cómo funciona un método antes de usarlo. La documentación nos informará de las posibles excepciones que tira un método y también indica las razones por las que pueden ocurrir estas excepciones. Después hay que incluir el código adecuado para manejarlas.