Prueba de Java ... captura
Java intenta... captura
En este tutorial, aprenderemos sobre la sentencia try catch en Java con la ayuda de ejemplos.
El try...catch
El bloque en Java se usa para manejar excepciones y evita la terminación anormal del programa.
Esta es la sintaxis de un try...catch
bloque en Java.
try{
// code
}
catch(exception) {
// code
}
El try
bloque incluye el código que podría generar una excepción.
El catch
block incluye el código que se ejecuta cuando ocurre una excepción dentro del try
bloquear.
Ejemplo:Java intenta... atrapar bloque
class Main {
public static void main(String[] args) {
try {
int divideByZero = 5 / 0;
System.out.println("Rest of code in try block");
}
catch (ArithmeticException e) {
System.out.println("ArithmeticException => " + e.getMessage());
}
}
}
Salida
ArithmeticException => / by zero
En el ejemplo anterior, observe la línea,
int divideByZero = 5 / 0;
Aquí, estamos tratando de dividir un número por cero . En este caso, se produce una excepción. Por lo tanto, hemos incluido este código dentro del try
bloquear.
Cuando el programa encuentra este código, ArithmeticException
ocurre. Y, la excepción es capturada por el catch
block y ejecuta el código dentro del catch
bloquear.
El catch
el bloque solo se ejecuta si existe una excepción dentro del try
bloquear.
Nota :En Java, podemos usar un try
bloque sin un catch
bloquear. Sin embargo, no podemos usar un catch
bloque sin un try
bloquear.
Intentar Java... finalmente bloquear
También podemos usar el try
bloque junto con un bloque finalmente.
En este caso, el bloque "finally" siempre se ejecuta ya sea que haya una excepción dentro del bloque "try" o no.
Ejemplo:prueba de Java... finalmente bloque
class Main {
public static void main(String[] args) {
try {
int divideByZero = 5 / 0;
}
finally {
System.out.println("Finally block is always executed");
}
}
}
Salida
Finally block is always executed Exception in thread "main" java.lang.ArithmeticException: / by zero at Main.main(Main.java:4)
En el ejemplo anterior, hemos utilizado el try
bloque junto con el finally
bloquear. Podemos ver que el código dentro del try
bloque está causando una excepción.
Sin embargo, el código dentro del finally
el bloque se ejecuta independientemente de la excepción.
Java intenta... atrapar... finalmente bloquear
En Java, también podemos usar el bloque finalmente después del try...catch
bloquear. Por ejemplo,
import java.io.*;
class ListOfNumbers {
// create an integer array
private int[] list = {5, 6, 8, 9, 2};
// method to write data from array to a fila
public void writeList() {
PrintWriter out = null;
try {
System.out.println("Entering try statement");
// creating a new file OutputFile.txt
out = new PrintWriter(new FileWriter("OutputFile.txt"));
// writing values from list array to Output.txt
for (int i = 0; i < 7; i++) {
out.println("Value at: " + i + " = " + list[i]);
}
}
catch (Exception e) {
System.out.println("Exception => " + e.getMessage());
}
finally {
// checking if PrintWriter has been opened
if (out != null) {
System.out.println("Closing PrintWriter");
// close PrintWriter
out.close();
}
else {
System.out.println("PrintWriter not open");
}
}
}
}
class Main {
public static void main(String[] args) {
ListOfNumbers list = new ListOfNumbers();
list.writeList();
}
}
Salida
Entering try statement Exception => Index 5 out of bounds for length 5 Closing PrintWriter
En el ejemplo anterior, hemos creado una matriz denominada lista y un archivo llamado output.txt . Aquí, estamos tratando de leer datos de la matriz y almacenarlos en el archivo.
Fíjate en el código,
for (int i = 0; i < 7; i++) {
out.println("Value at: " + i + " = " + list[i]);
}
Aquí, el tamaño de la matriz es 5
y el último elemento de la matriz está en list[4]
. Sin embargo, estamos tratando de acceder a elementos en a[5]
y a[6]
.
Por lo tanto, el código genera una excepción que es capturada por el bloque catch.
Desde el finally
bloque siempre se ejecuta, hemos incluido código para cerrar el PrintWriter
dentro del bloque finalmente.
Es una buena práctica usar el bloque finalmente para incluir un código de limpieza importante, como cerrar un archivo o una conexión.
Nota :Hay algunos casos en los que un finally
el bloque no se ejecuta:
- Uso de
System.exit()
método - Se produce una excepción en el
finally
bloquear - La muerte de un hilo
Múltiples bloques de captura
Para cada try
bloque, puede haber cero o más catch
bloques Varios catch
Los bloques nos permiten manejar cada excepción de manera diferente.
El tipo de argumento de cada catch
bloque indica el tipo de excepción que puede manejar. Por ejemplo,
class ListOfNumbers {
public int[] arr = new int[10];
public void writeList() {
try {
arr[10] = 11;
}
catch (NumberFormatException e1) {
System.out.println("NumberFormatException => " + e1.getMessage());
}
catch (IndexOutOfBoundsException e2) {
System.out.println("IndexOutOfBoundsException => " + e2.getMessage());
}
}
}
class Main {
public static void main(String[] args) {
ListOfNumbers list = new ListOfNumbers();
list.writeList();
}
}
Salida
IndexOutOfBoundsException => Index 10 out of bounds for length 10
En este ejemplo, hemos creado una matriz de enteros llamada arr
de tamaño 10 .
Dado que el índice de matriz comienza desde 0 , el último elemento de la matriz está en arr[9]
. Note la declaración,
arr[10] = 11;
Aquí, estamos tratando de asignar un valor al índice 10 . Por lo tanto, IndexOutOfBoundException
ocurre.
Cuando ocurre una excepción en el try
bloquear,
- La excepción se lanza al primer
catch
bloquear. El primercatch
bloque no maneja unIndexOutOfBoundsException
, por lo que se pasa al siguientecatch
bloque. - El segundo
catch
block en el ejemplo anterior es el controlador de excepciones apropiado porque maneja unIndexOutOfBoundsException
. Por lo tanto, se ejecuta.
Capturar Múltiples Excepciones
Desde Java SE 7 y versiones posteriores, ahora podemos capturar más de un tipo de excepción con un catch
bloquear.
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 catch
el bloque se separa mediante una barra vertical |
.
Su sintaxis es:
try {
// code
} catch (ExceptionType1 | Exceptiontype2 ex) {
// catch block
}
Para obtener más información, visite Java capturando múltiples excepciones.
Declaración de prueba con recursos de Java
El probar-con-recursos es una declaración de prueba que tiene una o más declaraciones de recursos.
Su sintaxis es:
try (resource declaration) {
// use of the resource
} catch (ExceptionType e1) {
// catch block
}
El recurso es un objeto que se cerrará al final del programa. Debe declararse e inicializarse en la sentencia try.
Tomemos un ejemplo.
try (PrintWriter out = new PrintWriter(new FileWriter("OutputFile.txt")) {
// use of the resource
}
El probar-con-recursos declaración 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 obtener más información, visite la declaración de prueba con recursos de Java.
Java