En el tutorial, aprenderemos sobre diferentes enfoques de manejo de excepciones en Java con la ayuda de ejemplos.
En el último tutorial, aprendimos sobre las excepciones de Java. Sabemos que las excepciones terminan anormalmente la ejecución de un programa.
Por eso es importante manejar las excepciones. Aquí hay una lista de diferentes enfoques para manejar excepciones en Java.
- intenta … atrapar bloque
- finalmente bloquear
- lanzar y lanzar palabra clave
1. Java try … catch block
El bloque try-catch se usa para manejar excepciones en Java. Aquí está la sintaxis de try… catch
block:
try ( // code ) catch(Exception e) ( // code )
Aquí, hemos colocado el código que podría generar una excepción dentro del try
bloque. A cada try
bloque le sigue un catch
bloque.
Cuando se produce una excepción, el catch
bloque la detecta. El catch
bloque no se puede utilizar sin el try
bloque.
Ejemplo: manejo de excepciones usando try… catch
class Main ( public static void main(String() args) ( try ( // code that generate exception int divideByZero = 5 / 0; System.out.println("Rest of code in try block"); ) catch (ArithmeticException e) ( System.out.println("ArithmeticException => " + e.getMessage()); ) ) )
Salida
ArithmeticException => / por cero
En el ejemplo, estamos tratando de dividir un número entre 0
. Aquí, este código genera una excepción.
Para manejar la excepción, hemos puesto el código 5 / 0
dentro del try
bloque. Ahora, cuando ocurre una excepción, try
se omite el resto del código dentro del bloque.
El catch
bloque detecta la excepción y se ejecutan las sentencias dentro del bloque catch.
Si ninguna de las declaraciones del try
bloque genera una excepción, el catch
bloque se omite.
2. Java finalmente bloquea
En Java, el finally
bloque siempre se ejecuta sin importar si hay una excepción o no.
El finally
bloque es opcional. Y, para cada try
bloque, solo puede haber un finally
bloque.
La sintaxis básica de finally
block es:
try ( //code ) catch (ExceptionType1 e1) ( // catch block ) finally ( // finally block always executes )
Si ocurre una excepción, el finally
bloque se ejecuta después del try… catch
bloque. De lo contrario, se ejecuta después del bloque try. Para cada try
bloque, solo puede haber un finally
bloque.
Ejemplo: Manejo de excepciones de Java usando el bloque
class Main ( public static void main(String() args) ( try ( // code that generates exception int divideByZero = 5 / 0; ) catch (ArithmeticException e) ( System.out.println("ArithmeticException => " + e.getMessage()); ) finally ( System.out.println("This is the finally block"); ) ) )
Salida
ArithmeticException => / por cero Este es el bloque finalmente
En el ejemplo anterior, dividimos un número por 0 dentro del try
bloque. Aquí, este código genera un ArithmeticException
.
La excepción es capturada por el catch
bloque. Y luego finally
se ejecuta el bloque.
Nota : Es una buena práctica utilizar el finally
bloque. Es porque puede incluir códigos de limpieza importantes como,
- código que podría omitirse accidentalmente al regresar, continuar o romper
- cerrar un archivo o conexión
3. Java throw y throws palabra clave
La throw
palabra clave Java se utiliza para lanzar explícitamente una única excepción.
Cuando tenemos throw
una excepción, el flujo del programa se mueve de un try
bloque a otro catch
.
Ejemplo: manejo de excepciones usando Java throw
class Main ( public static void divideByZero() ( // throw an exception throw new ArithmeticException("Trying to divide by 0"); ) public static void main(String() args) ( divideByZero(); ) )
Salida
Excepción en el hilo "main" java.lang.ArithmeticException: tratando de dividir por 0 en Main.divideByZero (Main.java:5) en Main.main (Main.java:9)
En el ejemplo anterior, estamos lanzando explícitamente el ArithmeticException
uso de la throw
palabra clave.
De manera similar, la throws
palabra clave se usa para declarar el tipo de excepciones que pueden ocurrir dentro del método. Se utiliza en la declaración del método.
Ejemplo: Java throws palabra clave
import java.io.*; class Main ( // declareing the type of exception public static void findFile() throws IOException ( // code that may generate IOException File newFile = new File("test.txt"); FileInputStream stream = new FileInputStream(newFile); ) public static void main(String() args) ( try ( findFile(); ) catch (IOException e) ( System.out.println(e); ) ) )
Salida
java.io.FileNotFoundException: test.txt (El sistema no puede encontrar el archivo especificado)
Cuando ejecutamos este programa, si el archivo test.txt no existe, FileInputStream
lanza un FileNotFoundException
que extiende la IOException
clase.
El findFile()
método especifica que IOException
se puede lanzar un. El main()
método llama a este método y maneja la excepción si se lanza.
Si un método no maneja excepciones, el tipo de excepciones que pueden ocurrir dentro de él debe especificarse en la throws
cláusula.
Para obtener más información, visite Java throw and throws.