81 - Excepciones en Java - try/catch

Java dispone de un mecanismo de capturar (catch) ciertos tipos de errores que solo pueden ser detectados en tiempo de ejecución del programa.

Los ejemplos más comunes que podemos nombrar de excepciones:

Tratar de convertir a entero un String que no contiene valores numéricos.
Tratar de dividir por cero.
Abrir un archivo de texto inexistente o que se encuentra bloqueado por otra aplicación.
Conectar con un servidor de bases de datos que no se encuentra activo.
Acceder a subíndices de vectores y matrices fuera de rango.

La captura de excepciones nos permite crear programas mucho más robustos y tolerante a fallas que ocurren en escasas situaciones, pero en caso que se presenten disponemos de un algoritmo alternativo para reaccionar a dicha situación evitando que el programa finalice su ejecución.

Veremos un ejemplo sin captura de excepciones y luego la sintaxis implementando su captura.

Problema:

Realizar la carga de un número entero por teclado e imprimir su cuadrado.

Programa:

import java.util.Scanner;

public class CuadradoNumero {
    public static void main(String[] ar) {
        Scanner teclado = new Scanner(System.in);
        int num;
        System.out.print("Ingrese un valor entero:");
        num = teclado.nextInt();
        int cuadrado = num * num;
        System.out.print("El cuadrado de " + num + " es " + cuadrado);
    }
}

Si ejecutamos el programa y el operador ingresa un String en lugar de un entero se genera una excepción y el programa se detiene en forma inmediata:

El programa no ejecuta más instrucciones después de la línea 8 del método main. Se informa el nombre de excepción generada: java.util.InputMismatchException, es decir se nos informa el nombre de clase de excepción y el paquete que la contiene: java.util

Lo primero que podemos decir es que éste tipo de excepciones no son obligatorias capturarlas, pero como vemos si nuestro usuario del programa en forma frecuente se equivoca y carga cadenas en lugar de enteros el programa se detiene y requiere que lo vuelva a ejecutar.

Podemos implementar un programa más robusto si capturamos la excepción InputMismatchException y le informamos al usuario que debe ingresar un entero obligatoriamente.

Veamos ahora la sintaxis del mismo programa pero capturando la excepción:

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

public class CuadradoNumero {
    public static void main(String[] ar) {
        Scanner teclado = new Scanner(System.in);
        int num;
        try {
            System.out.print("Ingrese un valor entero:");
            num = teclado.nextInt();
            int cuadrado = num * num;
            System.out.print("El cuadrado de " + num + " es " + cuadrado);
        } catch (InputMismatchException ex) {
            System.out.println("Debe ingresar obligatoriamente un número entero.");
        }
    }
}

Para atrapar las excepciones debemos encerrar en un bloque try las instrucciones que generan excepciones, en nuestro caso el método 'nextInt' de la clase Scanner:

        try {
            System.out.print("Ingrese un valor entero:");
            num = teclado.nextInt();
            int cuadrado = num * num;
            System.out.print("El cuadrado de " + num + " es " + cuadrado);
        }

Todo bloque try requiere que sea seguido por un bloque catch:

        catch (InputMismatchException ex) {
            System.out.println("Debe ingresar obligatoriamente un número entero.");
        }

Luego de la palabra clave catch se indica entre paréntesis el nombre de un parámetro cualquiera (en nuestro caso lo llamamos 'ex') y el nombre de la excepción a capturar.

El bloque catch normalmente no se ejecuta salvo en los casos excepcionales que dentro del bloque try informa que se disparó dicha excepción.

Ahora si ejecutamos el programa y el operador ingresa un String en lugar de un entero nuestro programa no se detiene sino se le informa el tipo de error que cometió el usuario:

Cuando se dispara una excepción las instrucciones que hay luego del método que la disparó no se ejecutan:

            num = teclado.nextInt();
            int cuadrado = num * num;
            System.out.print("El cuadrado de " + num + " es " + cuadrado);

La dos instrucciones luego de llamar al método 'nextInt' no se ejecutan si dicho método eleva la excepción.

Podemos modificar ahora nuestro programa aun más para que no finalice hasta que cargue un valor entero:

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

public class CuadradoNumero {
    public static void main(String[] ar) {
        Scanner teclado = new Scanner(System.in);
        int num;
        boolean continua;
        do {
            try {
                continua = false;
                System.out.print("Ingrese un valor entero:");
                num = teclado.nextInt();
                int cuadrado = num * num;
                System.out.print("El cuadrado de " + num + " es " + cuadrado);
            } catch (InputMismatchException ex) {
                System.out.println("Debe ingresar obligatoriamente un número entero.");
                teclado.next();
                continua = true;
            }
        } while (continua);
    }
}