Excepciones en Java

El manejo de excepciones en Java es uno de los medios efectivos para manejar los errores de tiempo de ejecución para que se pueda preservar el flujo regular de la aplicación. El manejo de excepciones de Java es un mecanismo para manejar errores de tiempo de ejecución como ClassNotFoundException, IOException, SQLException, RemoteException, etc.

La excepción es un evento no deseado o inesperado que ocurre durante la ejecución de un programa, es decir, en tiempo de ejecución, que interrumpe el flujo normal de las instrucciones del programa. Las excepciones pueden ser capturadas y manejadas por el programa. Cuando ocurre una excepción dentro de un método, crea un objeto. Este objeto se denomina objeto de excepción. Contiene información sobre la excepción, como el nombre y la descripción de la excepción y el estado del programa cuando se produjo la excepción.

Razones principales por las que ocurre una excepción

• Entrada de usuario no válida
• Fallo del dispositivo
• Pérdida de conexión de red
• Limitaciones físicas (sin memoria de disco)
• Errores de código
• Abrir un archivo no disponible

Los errores representan condiciones irrecuperables, como que la máquina virtual Java (JVM) se quede sin memoria, fugas de memoria, errores de desbordamiento de pila, incompatibilidad de bibliotecas, recursividad infinita, etc. Los errores suelen estar fuera del control del programador y no debemos tratar de manejarlos. .

Analicemos la parte más importante, que son las diferencias entre Error y Excepción, que es la siguiente: 

• Error:  un error indica un problema grave que una aplicación razonable no debería tratar de detectar.
• Excepción:  la excepción indica condiciones que una aplicación razonable podría intentar capturar.

Jerarquía de excepciones

Todos los tipos de excepciones y errores son subclases de la clase Throwable , que es la clase base de la jerarquía. Una rama está encabezada por Exception . Esta clase se utiliza para condiciones excepcionales que los programas de usuario deben detectar. NullPointerException es un ejemplo de tal excepción. Otra rama, Error , es utilizada por el sistema de tiempo de ejecución de Java ( JVM ) para indicar errores que tienen que ver con el propio entorno de tiempo de ejecución (JRE). StackOverflowError es un ejemplo de este tipo de error.

Tipos de excepciones 

Java define varios tipos de excepciones que se relacionan con sus diversas bibliotecas de clases. Java también permite a los usuarios definir sus propias excepciones.

Las excepciones se pueden categorizar de dos maneras:

1. Excepciones integradas
   • Excepción marcada
   • Excepción no verificada 
2. Excepciones definidas por el usuario

Analicemos la excepción mencionada anteriormente definida que es la siguiente:

A. Excepciones integradas:

Las excepciones integradas son las excepciones que están disponibles en las bibliotecas de Java. Estas excepciones son adecuadas para explicar ciertas situaciones de error.

• Excepciones verificadas: las excepciones verificadas se denominan excepciones en tiempo de compilación porque el compilador verifica estas excepciones en tiempo de compilación.
   
• Excepciones no verificadas: las excepciones no verificadas son justo lo contrario de las excepciones verificadas. El compilador no verificará estas excepciones en tiempo de compilación. En palabras simples, si un programa arroja una excepción no verificada, e incluso si no la manejamos ni la declaramos, el programa no generaría un error de compilación.

Nota: Para la excepción marcada vs no marcada, consulte Excepciones marcadas vs no marcadas 

B. Excepciones definidas por el usuario:

A veces, las excepciones integradas en Java no pueden describir una situación determinada. En tales casos, los usuarios también pueden crear excepciones, que se denominan ‘Excepciones definidas por el usuario’. 

Las ventajas del manejo de excepciones en Java son las siguientes:

1. Provisión para Completar la Ejecución del Programa
2. Fácil identificación del código de programa y el código de manejo de errores
3. Propagación de errores
4. Informes de errores significativos
5. Identificación de tipos de errores

Métodos para imprimir la información de Excepción:

1.printStackTrace() : este método imprime información de excepción en el formato Nombre de la excepción: descripción de la excepción, pila

rastro.

//program to print the exception information using printStackTrace() method
 
import java.io.*;
 
class GFG {
    public static void main (String[] args) {
      int a=5;
      int b=0;
        try{
          System.out.println(a/b);
        }
      catch(ArithmeticException e){
        e.printStackTrace();
      }
    }
}

Producción:

java.lang.ArithmeticException: / by zero
at GFG.main(File.java:10)

2.toString(): este método imprime información de excepción en el formato Nombre de la excepción: descripción de la excepción.

//program to print the exception information using toString() method
 
import java.io.*;
 
class GFG1 {
    public static void main (String[] args) {
      int a=5;
      int b=0;
        try{
          System.out.println(a/b);
        }
      catch(ArithmeticException e){
        System.out.println(e.toString());
      }
    }
}

Producción:

java.lang.ArithmeticException: / by zero

3.getMessage(): este método imprime solo la descripción de la excepción.

//program to print the exception information using getMessage() method
 
import java.io.*;
 
class GFG1 {
    public static void main (String[] args) {
      int a=5;
      int b=0;
        try{
          System.out.println(a/b);
        }
      catch(ArithmeticException e){
        System.out.println(e.getMessage());
      }
    }
}

Producción:

/ by zero

¿Cómo maneja JVM una excepción?

Manejo de excepciones predeterminado: siempre que se produzca una excepción dentro de un método, el método crea un objeto conocido como objeto de excepción y lo pasa al sistema de tiempo de ejecución (JVM). El objeto de excepción contiene el nombre y la descripción de la excepción y el estado actual del programa donde ocurrió la excepción. Crear el objeto de excepción y manejarlo en el sistema de tiempo de ejecución se denomina lanzar una excepción. Puede haber una lista de los métodos que se llamaron para llegar al método donde ocurrió una excepción. Esta lista ordenada de los métodos se llama Call Stack . Ahora ocurrirá el siguiente procedimiento. 

• El sistema de tiempo de ejecución busca en la pila de llamadas para encontrar el método que contiene un bloque de código que puede manejar la excepción que ocurrió. El bloque del código se denomina controlador de excepciones .
• El sistema en tiempo de ejecución comienza a buscar desde el método en el que ocurrió la excepción y continúa a través de la pila de llamadas en el orden inverso al que se llamaron los métodos.
• Si encuentra un controlador apropiado, le pasa la excepción ocurrida. Un controlador adecuado significa que el tipo de objeto de excepción lanzado coincide con el tipo de objeto de excepción que puede manejar.
• Si el sistema en tiempo de ejecución busca todos los métodos en la pila de llamadas y no pudo encontrar el controlador adecuado, entonces el sistema en tiempo de ejecución transfiere el objeto de excepción al controlador de excepciones predeterminado , que forma parte del sistema en tiempo de ejecución. Este controlador imprime la información de la excepción en el siguiente formato y finaliza el programa de forma anormal .

Exception in thread "xxx" Name of Exception : Description
... ...... ..  // Call Stack

Mire el siguiente diagrama para comprender el flujo de la pila de llamadas. 

Ilustración:

// Java Program to Demonstrate How Exception Is Thrown
 
// Class
// ThrowsExecp
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Taking an empty string
        String str = null;
        // Getting length of a string
        System.out.println(str.length());
    }
}

Producción:

 

Veamos un ejemplo que ilustra cómo un sistema en tiempo de ejecución busca el código de manejo de excepciones adecuado en la pila de llamadas.

Ejemplo:

// Java Program to Demonstrate Exception is Thrown
// How the runTime System Searches Call-Stack
// to Find Appropriate Exception Handler
 
// Class
// ExceptionThrown
class GFG {
 
    // Method 1
    // It throws the Exception(ArithmeticException).
    // Appropriate Exception handler is not found
    // within this method.
    static int divideByZero(int a, int b)
    {
 
        // this statement will cause ArithmeticException
        // (/by zero)
        int i = a / b;
 
        return i;
    }
 
    // The runTime System searches the appropriate
    // Exception handler in method also but couldn't have
    // found. So looking forward on the call stack
    static int computeDivision(int a, int b)
    {
 
        int res = 0;
 
        // Try block to check for exceptions
        try {
 
            res = divideByZero(a, b);
        }
 
        // Catch block to handle NumberFormatException
        // exception Doesn't matches with
        // ArithmeticException
        catch (NumberFormatException ex) {
            // Display message when exception occurs
            System.out.println(
                "NumberFormatException is occurred");
        }
        return res;
    }
 
    // Method 2
    // Found appropriate Exception handler.
    // i.e. matching catch block.
    public static void main(String args[])
    {
 
        int a = 1;
        int b = 0;
 
        // Try block to check for exceptions
        try {
            int i = computeDivision(a, b);
        }
 
        // Catch block to handle ArithmeticException
        // exceptions
        catch (ArithmeticException ex) {
 
            // getMessage() will print description
            // of exception(here / by zero)
            System.out.println(ex.getMessage());
        }
    }
}

/ by zero

¿Cómo maneja el programador una excepción?

Gestión de excepciones personalizada: la gestión de excepciones de Java se gestiona a través de cinco palabras clave: try , catch , throw , throws y finalmente .. Brevemente, así es como funcionan. Las declaraciones de programa que cree que pueden generar excepciones están contenidas dentro de un bloque de prueba. Si ocurre una excepción dentro del bloque try, se lanza. Su código puede capturar esta excepción (usando el bloque catch) y manejarla de manera racional. Las excepciones generadas por el sistema son lanzadas automáticamente por el sistema de tiempo de ejecución de Java. Para lanzar manualmente una excepción, use la palabra clave throw. Cualquier excepción que se arroja fuera de un método debe especificarse como tal mediante una cláusula throws. Cualquier código que deba ejecutarse absolutamente después de que se complete un bloque de prueba se coloca en un bloque de finalización.

Sugerencia: Uno debe pasar por el flujo de control en el bloque de prueba y captura final para una mejor comprensión.  

Necesidad de una cláusula try-catch (Manejo de excepciones personalizado)

Considere el siguiente programa para obtener una mejor comprensión de la cláusula try-catch.

Ejemplo:

// Java Program to Demonstrate
// Need of try-catch Clause
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Taking an array of size 4
        int[] arr = new int[4];
 
        // Now this statement will cause an exception
        int i = arr[4];
 
        // This statement will never execute
        // as above we caught with an exception
        System.out.println("Hi, I want to execute");
    }
}

Producción: 

 

Explicación de salida: en el ejemplo anterior, una array se define con el tamaño, es decir, puede acceder a los elementos solo desde el índice 0 al 3. Pero está tratando de acceder a los elementos en el índice 4 (por error), por eso está generando una excepción. En este caso, JVM finaliza el programa de forma anormal . La sentencia System.out.println(“Hola, quiero ejecutar”); nunca se ejecutará. Para ejecutarlo, debemos manejar la excepción usando try-catch. Por lo tanto, para continuar con el flujo normal del programa, necesitamos una cláusula try-catch. 

¿Cómo usar la cláusula try-catch?

try {
    // block of code to monitor for errors
    // the code you think can raise an exception
} catch (ExceptionType1 exOb) {
    // exception handler for ExceptionType1
} catch (ExceptionType2 exOb) {
    // exception handler for ExceptionType2
}
// optional
finally {  // block of code to be executed after try block ends 
}

Ciertos puntos clave a continuación son necesarios para recordar que son los siguientes:   

• En un método, puede haber más de una declaración que podría generar una excepción, así que coloque todas estas declaraciones dentro de su propio bloque de prueba y proporcione un controlador de excepción separado dentro de su propio bloque catch para cada una de ellas.
• Si ocurre una excepción dentro del bloque de prueba , esa excepción es manejada por el controlador de excepciones asociado con ella. Para asociar el controlador de excepciones, debemos colocar un bloque catch después. Puede haber más de un controlador de excepciones. Cada bloque catch es un controlador de excepciones que maneja la excepción al tipo indicado por su argumento. El argumento ExceptionType declara el tipo de excepción que puede manejar y debe ser el nombre de la clase que hereda de la clase Throwable .
• Para cada bloque de prueba, puede haber cero o más bloques de captura, pero solo un bloque final.
• El bloque finalmente es opcional. Siempre se ejecuta ya sea que ocurra una excepción en el bloque de prueba o no. Si ocurre una excepción, se ejecutará después de intentar y capturar bloques.  Y si no ocurre una excepción, se ejecutará después del bloque de prueba . El bloque «finally» en Java se usa para colocar códigos importantes, como código de limpieza, por ejemplo, cerrar el archivo o cerrar la conexión.

El resumen se representa a través de la ayuda visual a continuación de la siguiente manera: 

 

Artículos relacionados:  

• Tipos de excepciones en Java
• Excepciones marcadas vs no marcadas
• Lanzar-Lanzar en Java

Este artículo es una contribución de Nitsdheerendra y Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente. 

Cursos relacionados

Fundamentos de programación Java: curso a su propio ritmo

Encuentre el curso adecuado para que comience a aprender la base de programación Java de la mano de expertos de la industria con años de experiencia. Este curso básico de programación Java : curso a su propio ritmo cubre los fundamentos del lenguaje de programación Java, tipos de datos, operadores y control de flujo, bucles, strings y mucho más. ¡No más esperas! ¡Comience a aprender JAVA ahora y conviértase en un completo ingeniero de Java!