Excepciones

Las excepciones son eventos inesperados que ocurren en las aplicaciones cuando alguna función ha generado un error, lo que provoca la detención de la aplicación o algún flujo inadecuado.

Estas excepciones ocurren en tiempo de ejecución. Sin embargo, pueden ser gestionadas gracias al manejo de excepciones de Java, que nos permite tratarlas cuando ocurran.

Jerarquía de excepciones

Todas las excepciones son representadas por clases. El JDK de Java provee una clase llamada Throwable, por lo tanto cuando ocurre una excepción, será de tipo Throwable.

Existen dos clases que heredan directamente de Throwable, la clase Exception y Error. Todas las excepciones que sean de tipo Error son provocadas por la JVM y no están directamente relacionadas con tu programa, por lo tanto no son excepciones que puedan ser gestionadas directamente.

Sin embargo, todas las excepciones que sean de tipo Exception son provocadas por las aplicaciones y deben ser tratadas (o evitadas). Algunas muy comunes son: NullPointerException, ArrayIndexOutOfBoundsException, IOException, entre muchas otras.

¿Cómo gestionar las excepciones?

Java nos proporciona un pequeño conjunto de palabras reservadas con el cual podemos manejar las excepciones. Estas son: try, catch y finally.

Manejar una excepción

Cuando puede ocurrir una excepción en tiempo de ejecución haremos uso de try, catch y finally en forma de bloque. La sintaxis es la siguiente:

                                
    try {
        // Bloque de instrucciones donde puede ocurrir el error.
    } catch(Exception ex1) {
        // Bloque de instrucciones para tratar el error.
    }
    } catch(Exception ex2) {
        // Bloque de instrucciones para tratar el error.
    } finally {
        // Bloque de instrucciones que será ejecutado cuando se origine o no alguna excepción.
    }
                                

En el bloque try {} se colocará el código que al ejecutarse pueda disparar algún tipo de Exception. Es decir, si queremos gestionar alguna excepción debemos de incluir dentro de este bloque las instrucciones que puedan dispararla. Esta será gestionada en algún bloque catch definido posteriormente.

Recordemos que hay muchos tipos de excepciones, cada clase que herede de Exception es una de ellas. Por lo tanto cada bloque catch (Exception ex) atrapa una y la gestiona de manera diferente dentro de su bloque.

Si una excepción es atrapada durante la ejecución del programa, los demás bloques catch ya no serán ejecutados.

Además existe el bloque finally. En él se escribirán las instrucciones que se deben de ejecutar se origine una excepción de cualquier tipo o cuando no ocurra ninguna. Esta parte del bloque es opcional.

Ejemplo:

                            
    public class Ejemplo {

        private static final Scanner sc = new Scanner(System.in);

        public static void main(String[] args) {
            System.out.println("*** Calcular la división de dos números ***");
            System.out.println("Ingresa el divisor (número entero): ");
            int divisor = sc.nextInt();
            System.out.println("Ingresa el dividendo (número entero): ");
            int dividendo = sc.nextInt();
            int resultado = divisor / dividendo;
            System.out.println("El resultado es: " + resultado);
        }
    }
                            
                            

Para ejemplificar el uso del try - catch - finally, vamos a usar el código anterior. Básicamente es un pequeño programa que realiza la división de dos números. El usuario tiene que ingresar los números que quiere dividir y el programa lo resolverá y mostrará el resultado. Aquí hay dos excepciones que pueden ser detonadas: La primera es un InputMismatchException, debido a que en la entrada de los números por parte del usuario se podría ingresar algún caracter que no sea numérico. Y la segunda: Un ArithmeticException, cuando en el valor del dividendo ingresen el valor de cero. Te recomendamos realizar la prueba.

Entonces para manejar esos errores que podrían ocurrir en tiempo de ejecución, modificaremos el código anterior incluyendo el try - catch - finally.

Ejemplo incluyendo manejo de excepciones:

                            
    public class Ejemplo {

        private static final Scanner sc = new Scanner(System.in);
        public static void main(String[] args) {
            System.out.println("*** Calcular la división de dos números ***");
            try {
                System.out.println("Ingresa el divisor (número entero): ");
                int divisor = sc.nextInt();
                System.out.println("Ingresa el dividendo (número entero): ");
                int dividendo = sc.nextInt();
                int resultado = divisor / dividendo;
                System.out.println("El resultado es: " + resultado);
            } catch(ArithmeticException ex) {
                System.out.println("No es posible dividir sobre cero.");
            } catch(InputMismatchException ex) {
                System.out.println("Los valores ingresados deben ser números.");
            } finally {
                System.out.println("Gracias por visitar @codigazosit.");
            }
        }
    }
                            
                        

Como podrás notar, hemos incluido los bloques para cada excepción que pueda ocurrir en el programa y le mostramos un mensaje diferente en cada caso al usuario. De esta manera la aplicación no termina debido al error y puede continuar con el flujo habitual. También podrás darte cuenta del mensaje en el bloque finally se ejecuta cuando cualquiera de las dos excepciones ocurre y cuando la ejecución fluye con éxito.

Ejemplo con Exception

                            
    public class Ejemplo {

        private static final Scanner sc = new Scanner(System.in);
        public static void main(String[] args) {
            System.out.println("*** Calcular la división de dos números ***");
            try {
                System.out.println("Ingresa el divisor (número entero): ");
                int divisor = sc.nextInt();
                System.out.println("Ingresa el dividendo (número entero): ");
                int dividendo = sc.nextInt();
                int resultado = divisor / dividendo;
                System.out.println("El resultado es: " + resultado);
            } catch(Exception ex) {
                System.out.println("Error en la ejecución.");
            } finally {
                System.out.println("Gracias por visitar @codigazosit.");
            }
        }
    }
                            
                        

Si no es necesario darle un tratamiento para cada tipo de excepción, podemos incluir en el bloque catch la clase Exception (Que es la clase de la cual heredan todas las excepciones). Cuando hacemos esto cualquier excepción que se origine caerá en este bloque de código.

Conclusión

Con el manejo de excepciones tenemos la posibilidad de manejar los errores que puedan ocurrir al momento de ejecutar nuestros programas para evitar que se detengan, además de que gracias a esto, las aplicaciones son más tolerantes a fallas y muestran un mejor comportamiento hacia los usuarios.

El código lo podrás encontrar en nuestro repositorio de GitHub

No olvides visitar nuestra cuenta de Instagram @codigazosit

Te compartimos algunos posts de este artículo por si tienes alguna duda o comentario.

¡Muchas gracias por tu visita!