Manejo de excepciones de Java

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.

intentar... atrapar bloque
bloquear finalmente
lanza y lanza palabra clave

1. Java intenta... atrapar bloque

El bloque try-catch se usa para manejar excepciones en Java. Esta es la sintaxis de try...catch bloque:

try {
  // code
}
catch(Exception e) {
  // code
}

Aquí, hemos colocado el código que podría generar una excepción dentro del try bloquear. Cada try bloque es seguido por un catch bloquear.

Cuando ocurre una excepción, es capturada por el catch bloquear. El catch el bloque no se puede usar sin el try bloquear.

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 => / by zero

En el ejemplo, estamos tratando de dividir un número por 0 . Aquí, este código genera una excepción.

Para manejar la excepción, hemos puesto el código, 5 / 0 dentro del try bloquear. Ahora, cuando ocurre una excepción, el resto del código dentro del try se salta el bloque.

El catch El bloque captura la excepción y se ejecutan las declaraciones dentro del bloque catch.

Si ninguna de las declaraciones en el try bloque genera una excepción, el catch se salta el bloque.

2. Java finalmente bloque

En Java, el finally bloque siempre se ejecuta sin importar si hay una excepción o no.

El finally bloque es opcional. Y, por cada try bloque, solo puede haber un finally bloquear.

La sintaxis básica de finally bloque es:

try {
  //code
}
catch (ExceptionType1 e1) { 
  // catch block
}
finally {
  // finally block always executes
}

Si ocurre una excepción, el finally el bloque se ejecuta después del try...catch bloquear. De lo contrario, se ejecuta después del bloque try. Para cada try bloque, solo puede haber un finally bloquear.

Ejemplo:Manejo de excepciones de Java usando el bloque finalmente

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 => / by zero
This is the finally block

En el ejemplo anterior, estamos dividiendo un número por 0 dentro del try bloquear. Aquí, este código genera un ArithmeticException .

La excepción es capturada por el catch bloquear. Y luego el finally se ejecuta el bloque.

Nota :Es una buena práctica usar el finally bloquear. Es porque puede incluir códigos de limpieza importantes como,

código que podría omitirse accidentalmente al regresar, continuar o interrumpir
cerrar un archivo o conexión

3. Java lanza y lanza palabra clave

Java throw La palabra clave se usa para lanzar explícitamente una única excepción.

Cuando throw una excepción, el flujo del programa se mueve desde el try bloque al catch bloquear.

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

Exception in thread "main" java.lang.ArithmeticException: Trying to divide by 0
        at Main.divideByZero(Main.java:5)
        at Main.main(Main.java:9)

En el ejemplo anterior, lanzamos explícitamente el ArithmeticException usando el throw palabra clave.

Del mismo modo, el throws La 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 arroja una 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 (The system cannot find the file specified)

Cuando ejecutamos este programa, si el archivo test.txt no existe, FileInputStream lanza un FileNotFoundException que extiende el IOException clase.

El findFile() especifica que un IOException se puede tirar El main() method 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 el throws cláusula.

Para obtener más información, visite Java throw and throws.

Excepciones de Java Prueba de Java ... captura

Java