try catch finally
En este tutorial, analizaremos varias palabras clave utilizadas en Java para el manejo de excepciones, como Try, Catch, Finalmente, Throw y Throws con ejemplos:
En nuestros tutoriales anteriores, hemos visto los conceptos básicos del manejo de excepciones en Java junto con las diversas excepciones admitidas por la clase Java Exception. También discutimos la NullPointerException en detalle.
Podemos incluir excepciones en nuestro programa mediante el uso de ciertas palabras clave que se proporcionan en Java. Estas palabras clave definen varios bloques de código que facilitan la definición y el manejo de excepciones.
=> Visite aquí para ver la serie exclusiva de tutoriales de capacitación en Java.
Lo que vas a aprender:
Prueba, captura, finalmente en Java
Las siguientes palabras clave se utilizan en Java para el manejo de excepciones.
- Tratar
- Captura
- Finalmente
- Lanzar
- Lanza
La siguiente tabla describe brevemente estas palabras clave.
| Palabra clave | Descripción |
|---|---|
| Tratar | Especificamos el bloque de código que podría dar lugar a la excepción en un bloque especial con una palabra clave 'Try'. |
| Captura | Cuando se genera la excepción, debe ser detectada por el programa. Esto se hace usando una palabra clave 'captura'. Entonces, un bloque catch sigue al bloque try que genera una excepción. La palabra clave catch siempre debe usarse con un intento. |
| Finalmente | A veces tenemos un código importante en nuestro programa que debe ejecutarse independientemente de si se lanza o no la excepción. Este código se coloca en un bloque especial que comienza con la palabra clave 'Finalmente'. El bloque Finalmente sigue al bloque Try-catch. |
| Lanzar | La palabra clave 'lanzar' se usa para lanzar la excepción explícitamente. |
| Lanza | La palabra clave 'Throws' no lanza una excepción, pero se utiliza para declarar excepciones. Esta palabra clave se utiliza para indicar que podría ocurrir una excepción en el programa o método. |
En este tutorial, analizaremos todas las palabras clave anteriores en detalle junto con los ejemplos de programación.
Prueba Block en Java
Siempre que escribimos un programa, podría haber un código que sospechamos que podría generar una excepción. Por ejemplo, podríamos sospechar que podría haber una operación de 'división por cero' en el código que producirá una excepción.
Este código que puede generar una excepción se incluye en un bloque con la palabra clave 'probar'. Entonces, el bloque try contiene el código o conjunto de declaraciones que pueden generar una excepción.
La sintaxis general del bloque try es la siguiente:
|_+_|Por lo tanto, si un programador piensa que ciertas declaraciones generarán excepciones, incluya estas declaraciones en un bloque try. Tenga en cuenta que cuando se produce una excepción en una declaración específica en un bloque try, el resto del código no se ejecuta.
Cuando ocurre una excepción en un bloque try en una declaración en particular, el control sale y el programa termina abruptamente. Para evitar esta terminación abrupta del programa, debemos 'manejar' esta excepción. Este manejo se realiza mediante la palabra clave 'catch'. Entonces, un bloque try siempre tiene un bloque catch siguiéndolo.
Bloquear captura en Java
Usamos un bloque de captura para manejar excepciones. Este es el bloque con la palabra clave 'catch'. El bloque catch sigue al bloque try.
Siempre que ocurre una excepción en el bloque try, se ejecuta el código en el bloque catch que corresponde a la excepción.
La sintaxis general del bloque catch es:
|_+_|Generalmente, la excepción declarada debe ser la clase principal de todas las excepciones, es decir, Exception. Pero si hay más de una excepción, también podemos escribir tipos de excepción específicos o excepciones generadas.
A continuación, discutiremos el bloque try-catch. Tenga en cuenta que para cada bloque try, podemos tener varios bloques catch.
Prueba-Catch Java
La sintaxis general del bloque try-catch se muestra a continuación:
|_+_|El bloque try puede tener varias líneas de código que pueden generar varias excepciones. Cada una de estas excepciones es manejada por un bloque de captura independiente.
El manejador de excepciones genérico, objeto e de la clase Exception puede manejar todas las excepciones, pero si queremos manejar excepciones específicas, entonces es aconsejable especificar el manejador de excepciones genérico como último bloque de captura.
Ejemplo de captura de prueba de Java
Ahora demostremos un bloque try-catch en Java. Aquí, en el bloque try, definimos una operación de división. El divisor es cero. Por tanto, el enunciado que divide los dos números genera una excepción aritmética. Tenemos un bloque de captura que define un controlador para la excepción aritmética.
A continuación se muestra un programa Java de ejemplo.
|_+_|Producción
¿Qué es una herramienta de recopilación de datos?
Captura de múltiples excepciones
Como ya se mencionó, un bloque try puede contener un código que genera más de una excepción. En este caso, necesitaremos más de un bloque de captura para manejar cada excepción. Un solo bloque de prueba puede ir seguido de varios bloques de captura. Cada bloque de captura manejará las excepciones independientes.
En el caso de varios bloques de captura, debemos recordar los siguientes puntos:
- En un programa Java, en cualquier momento, solo puede ocurrir una excepción. Además, en cualquier momento, solo se ejecuta un bloque de captura.
- Los bloques de captura múltiples deben ordenarse de tal manera que el bloque de captura para la excepción más específica debe ir primero y luego el general.
Por ejemplo, si tenemos ArithmeticException y general Exception, entonces el bloque catch que maneja ArithmeticException vendrá primero seguido por el bloque catch que maneja Exception.
El siguiente ejemplo muestra varios bloques de captura.
|_+_|Producción
En el programa anterior, se genera una ArithmeticException que se detecta en el primer bloque catch. Si no se especificó este bloque de captura, entonces la excepción se habría propagado al bloque de captura generalizado.
Modifiquemos ligeramente el programa anterior para que el bloque try genere dos excepciones. Ahora veamos el resultado.
|_+_|Producción
Si vemos esta salida, muestra ArrayIndexOutOfBoundsException lanzada. Esto se debe a que la instrucción que genera ArrayIndexOutOfBoundsException se ejecuta primero. Se lanza la excepción y el control pasa al bloque de captura correspondiente.
Try-Catch anidado
Un bloque try dentro de otro bloque try se denomina bloque try anidado. Necesitamos tales estructuras en ciertas situaciones cuando un fragmento de código contenido en un código de prueba puede ser tal que algunas líneas generen ciertas excepciones y otro fragmento de código genere una excepción completamente diferente.
En el caso de bloques try anidados, primero se ejecuta el bloque try más interno y se maneja la excepción. Si el bloque try más interno no tiene un bloque catch coincidente, entonces se propaga un nivel hasta su bloque try principal. De esta forma, la excepción se propaga hacia arriba hasta que se encuentra el manejador de excepciones correspondiente.
Si no hay un manejador de excepciones que coincida con la excepción, el programa finaliza abruptamente con un mensaje generado por el sistema.
La sintaxis general de un bloque try anidado se da a continuación:
|_+_|Implementemos un programa para demostrar el bloque try-catch anidado.
|_+_|Producción
En el programa anterior, tenemos dos bloques try encerrados en el bloque try principal. Ambos bloques de prueba internos tienen un código que genera ArithmeticException. Pero hemos proporcionado un bloque catch coincidente solo para el primer bloque y no para el segundo bloque try.
Por lo tanto, el segundo bloque propaga su excepción al bloque try principal y luego lo maneja. Esto es evidente por el resultado.
Finalmente bloquear en Java
Hasta ahora hemos visto el bloque try-catch y try anidado. Sabemos que el código que se espera que genere la excepción se coloca en un bloque try. Cuando ocurre una excepción, el resto del código en el bloque try no se ejecuta.
O el programa termina abruptamente si no se maneja una excepción o el control se pasa al manejador de excepciones.
En tal situación, surge la necesidad de incluir un código que deba ejecutarse independientemente de si se produce una excepción o no. Esto significa que ejecutaremos un fragmento de código incluso cuando ocurra una excepción y también cuando la excepción no ocurra.
Pero como el bloque try sale después de que se genera la excepción, no podemos poner este código en el bloque try. De manera similar, el bloque catch tiene un manejador de excepciones, por lo que no podemos ponerlo también en el bloque catch.
Por lo tanto, necesitamos un bloque separado que contenga un código que se ejecute independientemente de si se produce una excepción o no. Java proporciona un bloque 'finalmente' que contiene este fragmento de código.
Por lo tanto, un bloque finalmente en Java puede contener declaraciones críticas que se ejecutarán en el programa. La ejecución de estas declaraciones debe realizarse incluso cuando se produce una excepción o no.
Por lo tanto, colocaremos código como conexiones de cierre, objetos de flujo, etc. o cualquier código de limpieza en el bloque finalmente para que puedan ejecutarse incluso si ocurre una excepción.
El bloque finalmente en Java generalmente se coloca después de un bloque try o catch. Tenga en cuenta que el bloque finalmente no puede existir sin un bloque try. Cuando el bloque finalmente se incluye con try-catch, se convierte en un ' intentar atrapar finalmente ' cuadra.
Podemos omitir el bloque finalmente en el código de manejo de excepciones. Esto significa que el bloqueo final es opcional.
Si el bloque try no genera ninguna excepción, el bloque finalmente se ejecutará después del bloque try. Si hay una excepción en el bloque try, el control pasará primero al bloque catch y luego al bloque finalmente.
Una excepción que ocurre en el bloque finalmente se comporta de la misma manera que cualquier otra excepción. Incluso si el bloque try contiene una declaración de retorno o declaraciones de bifurcación como romper y continuar, el bloque finalmente se ejecutará.
Teniendo en cuenta estos puntos, sigamos adelante con la sintaxis general y ejemplos de bloque finalmente.
La sintaxis general del bloque finalmente es la siguiente:
|_+_|Aunque el bloqueo final siempre se ejecuta, hay ciertas situaciones o casos en los que no se ejecuta.
Estos son los siguientes casos:
- Cuando el hilo está muerto.
- Cuando se usa el método System.exit ().
- Cuando ocurre una excepción en el bloque finalmente.
Implementemos un par de programas para demostrar el bloque finalmente.
|_+_|Producción
El programa anterior muestra un bloque try-catch-finalmente. En el bloque try, se realiza una operación válida y, por lo tanto, no se lanza ninguna excepción. Por lo tanto, el control no se pasa para atrapar desde el intento sino para bloquear finalmente.
El siguiente programa es otro ejemplo de bloque try-catch-finalmente, pero en este caso, la excepción se lanza en el bloque try cuando realizamos una operación de división por cero. Por lo tanto, el bloque finalmente se ejecuta después de que se ejecuta el bloque try the catch.
|_+_|Producción
Lanzar una excepción en Java
Java proporciona una palabra clave 'lanzar' con la que podemos lanzar explícitamente las excepciones en el código. Por ejemplo, si estamos verificando operaciones aritméticas y queremos generar algunas excepciones después de verificar los operandos, podemos hacerlo usando la palabra clave 'throw'.
desarrollador de software en preguntas de entrevista de prueba
Usando la palabra clave throw, podemos lanzar las excepciones marcadas o no marcadas. La palabra clave throw también se usa para lanzar excepciones personalizadas.
La sintaxis general de la palabra clave throw es:
|_+_|A continuación se muestra un programa de ejemplo para demostrar la palabra clave throw.
|_+_|Producción
En el programa anterior, usamos un método para validar la edad. Si la edad es<18, then an exception is thrown to indicate the age is not valid.
Cláusula de lanzamientos
Hemos visto intentar bloquear para declarar excepciones. Contiene el código que puede generar excepciones. Hay otra forma de declarar una excepción y es usando la palabra clave 'throws'.
La declaración de excepción usando la palabra clave 'throws' le dice al programador que puede haber una excepción especificada después de la palabra clave 'throws' y el programador debe proporcionar el código de controlador correspondiente para esta excepción para mantener el flujo normal del programa.
Sin embargo, surge la pregunta de por qué necesitamos una palabra clave 'throws' cuando tenemos un bloque try-catch más confiable para declarar y manejar excepciones.
Una razón es que a medida que aumenta el número de excepciones que pueden ocurrir, el número de bloque catch que maneja excepciones también aumenta, ya que un bloque catch solo puede manejar una excepción.
De manera similar, si hay muchos métodos en un programa y cada método tiene numerosas excepciones, el código se volverá innecesariamente largo e inmanejable.
Por lo tanto, declarar una excepción con la palabra clave throws en la firma del método y luego manejar la llamada al método usando try-catch parece ser una solución viable.
Otra ventaja de declarar excepciones usando la palabra clave throws es que nos vemos obligados a manejar las excepciones. Si no proporcionamos un controlador para una excepción declarada, el programa generará un error.
La sintaxis general de la palabra clave throws es la siguiente:
|_+_|Implementemos ahora un programa Java para demostrar la palabra clave 'throws'.
En este programa, tenemos una clase Example_throw en la que tenemos un método testMethod. En la firma de este testMethod, declaramos dos excepciones IOException y Arithmetic Exception usando la palabra clave throws. Luego, en la función principal, las excepciones lanzadas son manejadas por el bloque catch.
|_+_|Producción
Preguntas frecuentes
P # 1) ¿Cuándo usar throws throw VS try-catch en Java?
Responder: La palabra clave 'throws' se utiliza para declarar la excepción con la firma del método. La palabra clave throw se usa para lanzar explícitamente la excepción. El bloque try-catch se usa para manejar las excepciones lanzadas por otros.
P # 2) ¿Podemos usar lanzamientos, intentar atrapar en un solo método?
Responder: No. No puede lanzar la excepción y también capturarla con el mismo método. La excepción que se declara usando throws debe manejarse en el método de llamada que llama al método que ha lanzado la excepción.
P # 3) ¿Qué sucede cuando un bloque de captura lanza una excepción?
Responder: Cuando se lanza una excepción en el bloque catch, el programa detendrá la ejecución. En caso de que el programa deba continuar, entonces debe haber un bloque try-catch separado para manejar la excepción generada en el bloque catch.
P # 4) ¿Qué es try-catch-finalmente en Java?
Responder: El bloque try-catch-finalmente contiene los tres bloques, es decir, try block, catch block y finalmente block.
El bloque Try contiene el código que podría generar una excepción. El bloque Catch contiene el controlador de excepciones para las excepciones en el bloque try. El bloque finalmente contiene el código crítico que se ejecutará independientemente de si la excepción ha ocurrido o no.
Q # 5) ¿Puede finalmente bloquear tener try-catch?
Responder: Sí, si tenemos un código de limpieza que podría lanzar una excepción en el bloque finalmente, entonces podemos tener un bloque try-catch. Sin embargo, parece feo.
Conclusión
En este tutorial, discutimos las diversas palabras clave utilizadas en el manejo de excepciones en Java. Hemos hablado de las palabras clave como intentar, atrapar, finalmente, lanzar y lanzar.
El código que posiblemente lanzará una excepción se incluye en el bloque try y catch proporciona el controlador para la excepción. El bloque finalmente ejecuta el código incluido en él, independientemente de si se lanza la excepción o no. El bloque finalmente sigue generalmente al bloque try o try-catch.
Usamos la palabra clave throws para declarar excepciones con la firma del método y throw se usa explícitamente para lanzar excepciones. Usualmente usamos la palabra clave throw para lanzar excepciones personalizadas.
=> Consulte la guía de formación de Java perfecta aquí.
Lectura recomendada
- Excepciones de Java y manejo de excepciones con ejemplos
- ¿Cómo manejar la excepción ArrayIndexOutOfBoundsException en Java?
- Tutorial de JAVA para principiantes: más de 100 tutoriales prácticos en vídeo de Java
- Manejo de excepciones JDBC: cómo manejar excepciones SQL
- Tutorial de manejo de excepciones de C # con ejemplos de código
- Guía completa para el manejo de excepciones PL SQL con ejemplos
- Manejo de excepciones en C ++
- Python Try Except: excepción de manejo de Python con ejemplos