Breaking

Post Top Ad

Your Ad Spot

jueves, 19 de diciembre de 2019

Manejo de excepciones Java

En este tutorial, aprenderá a manejar excepciones en Java con la ayuda de ejemplos. Para manejar las excepciones, usaremos try ... catch ... finalmente bloques.
En el último tutorial, aprendimos acerca de las excepciones. Las excepciones son eventos inesperados que ocurren durante la ejecución del programa.

Captura y manejo de excepciones

En Java, se utilizan los componentes de gestión de excepciones trycatchfinallylos bloques a excepción del mango.
Para detectar y manejar una excepción, colocamos el try...catch...finallybloque alrededor del código que podría generar una excepción. El finallybloque es opcional.
La sintaxis para try...catch...finallyes:
  1. try {
  2. // code
  3. } catch (ExceptionType e) {
  4. // catch block
  5. } finally {
  6. // finally block
  7. }

Java intenta ... atrapar bloque

El código que podría generar una excepción se coloca en el trybloque.
Cada trybloque debe ser seguido inmediatamente por el bloque catchfinallyCuando ocurre una excepción, es atrapada por el catchbloque que la sigue inmediatamente.
catchLos bloques no se pueden usar solos y siempre deben estar precedidos por un trybloque.

Ejemplo 1: intente ... atrapar bloques

  1. class Main {
  2. public static void main(String[] args) {
  3. try {
  4. int divideByZero = 5 / 0;
  5. System.out.println("Rest of code in try block");
  6. } catch (ArithmeticException e) {
  7. System.out.println("ArithmeticException => " + e.getMessage());
  8. }
  9. }
  10. }
Salida
ArithmeticException => / por cero
En el ejemplo,
  • Hemos dividido un número por 0 dentro del bloque try. Esto produce un ArithmeticException.
  • Cuando se produce la excepción, el programa omite el resto del código en el trybloque.
  • Aquí, hemos creado un bloque catch para manejar ArithmeticExceptionPor lo tanto, catchse ejecutan las declaraciones dentro del bloque.
Si ninguna de las declaraciones en el trybloque genera una excepción, catchse omite el bloque.

Múltiples bloques de captura

Para cada trybloque, puede haber cero o más catchbloques.
El tipo de argumento de cada catchbloque indica el tipo de excepción que puede manejar. Múltiples catchbloques nos permiten manejar cada excepción de manera diferente.

Ejemplo 2: múltiples bloques de captura

  1. class ListOfNumbers {
  2. public int[] arrayOfNumbers = new int[10];
  3. public void writeList() {
  4. try {
  5. arrayOfNumbers[10] = 11;
  6. } catch (NumberFormatException e1) {
  7. System.out.println("NumberFormatException => " + e1.getMessage());
  8. } catch (IndexOutOfBoundsException e2) {
  9. System.out.println("IndexOutOfBoundsException => " + e2.getMessage());
  10. }
  11. }
  12. }
  13. class Main {
  14. public static void main(String[] args) {
  15. ListOfNumbers list = new ListOfNumbers();
  16. list.writeList();
  17. }
  18. }
Salida
IndexOutOfBoundsException => Índice 10 fuera de límites para longitud 10
En este ejemplo, hemos declarado una matriz de enteros arrayOfNumbers de tamaño 10.
Sabemos que un índice de matriz siempre comienza desde 0. Entonces, cuando tratamos de asignar un valor al índice 10, IndexOutOfBoundsExceptionocurre porque los límites de la matriz para arrayOfNumbers son de 0 a 9.
Cuando ocurre una excepción en el trybloque,
  • La excepción se lanza al primer catchbloque. El primer catchbloque no maneja un IndexOutOfBoundsException, por lo que se pasa al siguiente catchbloque.
  • El segundo catchbloque en el ejemplo anterior es el manejador de excepciones apropiado porque maneja un IndexOutOfBoundsExceptionPor lo tanto, se ejecuta.

Java finalmente bloquea

Para cada trybloque, solo puede haber un finallybloque.
El finallybloque es opcional. Sin embargo, si se define, siempre se ejecuta (incluso si no se produce la excepción).
Si ocurre una excepción, se ejecuta después del try...catchbloque. Si no se produce una excepción, se ejecuta después del trybloque.
La sintaxis básica del finallybloque es:
  1. try {
  2. //code
  3. } catch (ExceptionType1 e1) {
  4. // catch block
  5. } catch (ExceptionType1 e2) {
  6. // catch block
  7. } finally {
  8. // finally block always executes
  9. }

Ejemplo 3: finalmente bloquear

  1. class Main {
  2. public static void main(String[] args) {
  3. try {
  4. int divideByZero = 5 / 0;
  5. } catch (ArithmeticException e) {
  6. System.out.println("ArithmeticException => " + e.getMessage());
  7. } finally {
  8. System.out.println("Finally block is always executed");
  9. }
  10. }
  11. }
Salida
ArithmeticException => / por cero
Finalmente el bloque siempre se ejecuta
En este ejemplo, hemos dividido un número entre 0. Esto arroja un número ArithmeticExceptionque es atrapado por el catchbloque. El finallybloque siempre se ejecuta.
Tener un finallybloqueo se considera una buena práctica. Es porque incluye un código de limpieza importante como:
  • código que podría haber sido accidentalmente omitido por returncontinuebreakdeclaraciones
  • cerrar un archivo o conexión
Hemos mencionado que finalmente siempre se ejecuta y ese suele ser el caso. Sin embargo, hay algunos casos en que un finallybloque no se ejecuta:
  • Uso del System.exit()método
  • Se produce una excepción en el finallybloque.
  • La muerte de un hilo

Ejemplo 4: prueba, atrapa y finalmente bloquea

Tomemos un ejemplo en el que intentamos crear un nuevo archivo usando FileWritery escribir datos en él usando PrintWriter.
  1. import java.io.*;
  2. class ListOfNumbers {
  3. private int[] list = new int[10];
  4. public ListOfNumbers() {
  5. // storing integer values in the list array
  6. for (int i = 0; i < 10; i++) {
  7. list[i] = i;
  8. }
  9. }
  10. }
  11. public void writeList() {
  12. PrintWriter out = null;
  13. try {
  14. System.out.println("Entering try statement");
  15. // creating a new file OutputFile.txt
  16. out = new PrintWriter(new FileWriter("OutputFile.txt"));
  17. // writing values from list array to the new created file
  18. for (int i = 0; i < 10; i++) {
  19. out.println("Value at: " + i + " = " + list[i]);
  20. }
  21. } catch (IndexOutOfBoundsException e1) {
  22. System.out.println("IndexOutOfBoundsException => " + e1.getMessage());
  23. } catch (IOException e2) {
  24. System.out.println("IOException => " + e2.getMessage());
  25. } finally {
  26. // checking if PrintWriter has been opened
  27. if (out != null) {
  28. System.out.println("Closing PrintWriter");
  29. out.close();
  30. } else {
  31. System.out.println("PrintWriter not open");
  32. }
  33. }
  34. }
  35. }
  36. class Main {
  37. public static void main(String[] args) {
  38. ListOfNumbers list = new ListOfNumbers();
  39. list.writeList();
  40. }
  41. }
Cuando ejecuta este programa, hay dos posibilidades que pueden ocurrir:
  1. Se produce una excepción en el trybloque.
  2. El trybloque se ejecuta normalmente
Una excepción puede ocurrir al crear nuevos FileWriterLanza un IOExceptionsi el archivo especificado no se puede crear o escribir.
Cuando ocurre una excepción, obtendremos el siguiente resultado.
Introducir declaración de prueba
IOException => OutputFile.txt
PrintWriter no está abierto
Cuando no se produce una excepción y el trybloque se ejecuta normalmente, obtendremos el siguiente resultado.
Introducir declaración de prueba
Cierre PrintWriter
Se OutputFile.txtcrea y tendrá el siguiente contenido:
Valor en: 0 = 0
Valor en: 1 = 1
Valor en: 2 = 2
Valor en: 3 = 3
Valor en: 4 = 4
Valor en: 5 = 5
Valor en: 6 = 6
Valor en: 7 = 7
Valor en: 8 = 8
Valor en: 9 = 9

Trabajo de prueba ... captura ... finalmente en detalle

Tratemos de comprender el flujo del manejo de excepciones en detalle con la ayuda del ejemplo anterior.
Trabajo de prueba ... captura ... finalmente en Java
La figura anterior describe el flujo de ejecución del programa cuando se produce una excepción al crear uno nuevo FileWriter.
  • Para llegar al método donde se produce la excepción, el método principal llama al writeList()método que luego llama al FileWriter()método para crear un nuevo OutputFile.txtarchivo.
  • Cuando ocurre una excepción, el sistema de tiempo de ejecución omite el resto del código en el trybloque.
  • Comienza a buscar en la pila de llamadas en orden inverso para encontrar un controlador de excepciones apropiado.
  • Aquí, FileWriterno tiene un controlador de excepción, por lo que el sistema de tiempo de ejecución verifica el siguiente método en la pila de llamadas, es decir writeList.
  • El writeListmétodo tiene dos manejadores de excepciones: uno que maneja IndexOutOfBoundsExceptiony otro que maneja IOException.
  • El sistema luego pasa por estos controladores en orden secuencial.
  • El primer controlador en este ejemplo maneja IndexOutOfBoundsExceptionEsto no coincide con el IOExceptionlanzado por el trybloque.
  • Entonces, se verifica el siguiente controlador, que es el IOExceptioncontrolador. Esto coincide con el tipo de excepción lanzada para que catchse ejecute el código en el bloque.
  • Después de que se ejecuta el controlador de excepciones, se ejecuta el finallybloque.
  • En este escenario, ya que se produjo una excepción en el FileWriter, la PrintStream objeto cabo nunca fue abierto y no necesita ser cerrado.
Ahora, supongamos que la excepción no ocurre mientras se ejecuta este programa y el trybloque se ejecuta normalmente. An OutputFile.txtse crea y se escribe en este caso.
Como sabemos, el finallybloque se ejecuta independientemente del manejo de excepciones. Como no se produjo ninguna excepción, el PrintWriterestá abierto y debe cerrarse. Esto se hace por out.close()declaración en el finallybloque.

Capturando múltiples excepciones

Desde Java SE 7 y versiones posteriores, ahora podemos capturar más de un tipo de excepción con un catchbloque.
Esto reduce la duplicación de código y aumenta la simplicidad y eficiencia del código.
Cada tipo de excepción que puede manejar el catchbloque se separa mediante una barra vertical |.
Su sintaxis es:
  1. try {
  2. // code
  3. } catch (ExceptionType1 | Exceptiontype2 ex) {
  4. // catch block
  5. }
Visite Java capturando múltiples excepciones para obtener más información.

La declaración de prueba con recursos

La declaración try-with-resources es una declaración try que tiene una o más declaraciones de recursos.
Su sintaxis es:
  1. try (resource declaration) {
  2. // use of the resource
  3. } catch (ExceptionType e1) {
  4. // catch block
  5. }
El recurso es un objeto que se cerrará al final del programa. Debe declararse e inicializarse en la instrucción try.
Pongamos un ejemplo.
  1. try (PrintWriter out = new PrintWriter(new FileWriter(“OutputFile.txt”)) {
  2. // use of the resource
  3. }
La declaración de prueba con recursos también se conoce como gestión automática de recursos . Esta declaración cierra automáticamente todos los recursos al final de la declaración.
Para conocerlo en detalle, visite la declaración de prueba con recursos de Java.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas