Manejo de excepciones en Java es uno de los medios eficaces para manejar errores de tiempo de ejecución para que se pueda preservar el flujo normal 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.
¿Qué son las excepciones de Java?
En Java, 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. El programa puede detectar y manejar excepciones. Cuando ocurre una excepción dentro de un método, crea un objeto. Este objeto se llama 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 ocurrió la excepción.
Razones principales por las que se produce una excepción
- Entrada de usuario no válida
- Fallo del dispositivo
- Pérdida de conexión de red
- Limitaciones físicas (memoria fuera del disco)
- Errores de código
- Abrir un archivo no disponible
Errores representan condiciones irrecuperables, como la máquina virtual Java (JVM) que se queda sin memoria, pérdidas de memoria, errores de desbordamiento de pila, incompatibilidad de biblioteca, recursividad infinita, etc. Los errores generalmente están fuera del control del programador y no debemos intentar manejarlos.
Diferencia entre error y excepción
Analicemos la parte más importante que es la diferencias entre error y excepción es decir, el siguiente:
- Error: Un error indica un problema grave que una aplicación razonable no debería intentar detectar.
- Excepción: La excepción indica condiciones que una aplicación razonable podría intentar detectar.
Jerarquía de excepciones
Todos los tipos de excepción y error son subclases de la clase. arrojable , que es la clase base de la jerarquía. Una rama está dirigida por Excepción . 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 utilizado por el sistema de tiempo de ejecución de Java ( JVM ) para indicar errores que tienen que ver con el propio entorno de ejecución (JRE). StackOverflowError es un ejemplo de tal error.
Jerarquía de excepciones de Java
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 clasificar de dos maneras:
- Excepciones integradas
- Excepción marcada
- Excepción no marcada
- Excepciones definidas por el usuario
Analicemos la excepción enumerada anteriormente definida que es la siguiente:
1. Excepciones integradas
Las excepciones integradas son las excepciones que están disponibles en las bibliotecas de Java. Estas excepciones son adecuadas para explicar determinadas situaciones de error.
- Excepciones marcadas: Las excepciones marcadas se denominan excepciones en tiempo de compilación porque el compilador las verifica en tiempo de compilación.
- Excepciones no marcadas: Las excepciones no marcadas son justo lo opuesto a las excepciones marcadas. El compilador no comprobará estas excepciones en el momento de la compilación. En palabras simples, si un programa arroja una excepción no verificada, e incluso si no la manejamos ni declaramos, el programa no dará un error de compilación.
Nota: Para excepciones marcadas y no marcadas, consulte Excepciones marcadas y no marcadas
2. 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'.
El ventajas del manejo de excepciones en Java son como sigue:
- Provisión para completar la ejecución del programa
- Fácil identificación del código de programa y del código de manejo de errores
- Propagación de errores
- Informes de errores significativos
- Identificar tipos de errores
Métodos para imprimir la información de excepción:
1. imprimirStackTrace()
Este método imprime información de excepción en el formato Nombre de la excepción: descripción de la excepción, seguimiento de la pila.
Ejemplo:
Java
//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()
El método toString() imprime información de excepción en el formato Nombre de la excepción: descripción de la excepción.
Ejemplo:
Java
//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. obtener mensaje()
El método getMessage() imprime solo la descripción de la excepción.
Ejemplo:
Java
jframe
//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 dentro de un método, si se ha producido una excepción, el método crea un objeto conocido como objeto de excepción y lo entrega 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 en tiempo de ejecución se denomina lanzar una excepción. Es posible que haya una lista de los métodos que se llamaron para llegar al método donde ocurrió una excepción. Esta lista ordenada de métodos se llama Pila de llamadas . Ahora sucederá el siguiente procedimiento.
- El sistema en tiempo de ejecución busca en la pila de llamadas el método que contiene un bloque de código que puede manejar la excepción ocurrida. El bloque del código se llama Manejador 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 apropiado 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 apropiado, entonces el sistema en tiempo de ejecución entrega el objeto de excepción al controlador de excepciones predeterminado , que es parte del sistema de tiempo de ejecución. Este controlador imprime la información de excepción en el siguiente formato y finaliza el programa. anormalmente .
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
// 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 apropiado en la pila de llamadas.
Ejemplo:
Java
// 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());> >}> >}> }> |
>
>Producción
/ by zero>
¿Cómo maneja el programador una excepción?
Manejo de excepciones personalizado: El manejo de excepciones de Java se gestiona mediante cinco palabras clave: intentar , atrapar , tirar , lanza , y finalmente . Brevemente, así es como funcionan. Las declaraciones de programa que cree que pueden generar excepciones están contenidas en un bloque de prueba. Si ocurre una excepción dentro del bloque try, se lanza. Su código puede detectar esta excepción (usando el bloque catch) y manejarla de alguna manera racional. Las excepciones generadas por el sistema son lanzadas automáticamente por el sistema de tiempo de ejecución de Java. Para lanzar una excepción manualmente, use la palabra clave throw. Cualquier excepción que se descarte de un método debe especificarse como tal mediante una cláusula throws. Cualquier código que sea absolutamente necesario ejecutar después de que se completa un bloque de prueba se coloca en un bloque finalmente.
Consejo: uno debe pasar controle el flujo en el bloque try catch finalmente para una mejor comprensión.
Necesidad de una cláusula try-catch (manejo de excepciones personalizado)
Considere el siguiente programa para comprender mejor la cláusula try-catch.
Ejemplo:
Java
// 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 matriz se define con tamaño, es decir, puede acceder a elementos solo del índice 0 al 3. Pero intenta acceder a los elementos en el índice 4 (por error), por eso genera una excepción. En este caso, JVM finaliza el programa. anormalmente . La declaración 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 utilizar 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 }> Es necesario recordar ciertos puntos clave 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 intentar bloquear y proporcionar un controlador de excepciones separado dentro de su propio atrapar bloque para cada uno de ellos.
- Si ocurre una excepción dentro del intentar bloque, esa excepción es manejada por el controlador de excepciones asociado a él. Para asociar el manejador de excepciones debemos poner un atrapar bloque después de él. Puede haber más de un controlador de excepciones. Cada atrapar block 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 del arrojable clase.
- Para cada bloque try, puede haber cero o más bloques catch, pero sólo uno bloque final.
- El bloque finalmente es opcional. Siempre se ejecuta independientemente de que se haya producido una excepción en el bloque try o no. Si ocurre una excepción, se ejecutará después Intenta atrapar bloques. Y si no ocurre una excepción, entonces se ejecutará después de la intentar bloquear. El bloque finalmente en Java se usa para colocar códigos importantes, como código de limpieza, por ejemplo, cerrar el archivo o cerrar la conexión.
- Si escribimos System.exit en el bloque try, entonces el bloque finalmente no se ejecutará.
El resumen se muestra mediante ayuda visual a continuación:
Artículos relacionados:
- Tipos de excepciones en Java
- Excepciones marcadas y no marcadas
- Lanzamientos en Java
Cursos relacionados
Fundamentos de programación Java: curso a su propio ritmo
Encuentre el curso adecuado para comenzar a aprender los fundamentos de programación Java de la mano de expertos de la industria con años de experiencia. Este Fundamentos de programación Java: curso a su propio ritmo cubre los fundamentos de la Lenguaje de programación Java, tipos de datos, operadores y control de flujo, bucles, cadenas. , y mucho más. ¡No más esperas! ¡Empiece a aprender JAVA ahora y conviértase en un completo ingeniero de Java!