· Bloques de prueba
· Bloques de captura
· Bloques finalmente
· Juntando todo
· Bloques de prueba anidados
· Captura de múltiples excepciones

Prueba bloques

Los bloques Try son la primera parte de los bloques Try/Catch. Contienen cualquier código que pueda causar una excepción. En Java, cuando no estamos seguros del resultado de una declaración, podemos poner esas declaraciones dentro de este bloque de prueba. Un bloque de prueba se puede usar en un método o en otro bloque de prueba.

El bloque try siempre va seguido de un bloque catch , que gestiona la excepción que se produce en el bloque try asociado.

Para IOExceptions, coloque cualquier código que esté creando, leyendo, escribiendo o cerrando un archivo dentro de un bloque de prueba

Sintaxis

El primer paso para construir un controlador de excepciones es encerrar el código que podría generar una excepción dentro de un bloque de prueba . En general, un bloque de prueba tiene el siguiente aspecto:

try {
    code
}
catch and finally blocks . . .

Ejemplo

Para construir un controlador de excepciones para el método writeList de la clase ListOfNumbers, encierre las declaraciones de lanzamiento de excepciones del método writeList dentro de un bloque de prueba . Hay más de una manera de hacer esto. Puede colocar cada línea de código que podría generar una excepción dentro de su propio bloque de prueba y proporcionar controladores de excepción separados para cada uno. O bien, puede colocar todo el código de writeList dentro de un único bloque de prueba y asociarle varios controladores. La siguiente lista usa un bloque de prueba para todo el método porque el código en cuestión es muy corto.

private List<Integer> list;
private static final int SIZE = 10;

public void writeList() {
    PrintWriter out = null;
    try {
        System.out.println("Entered try statement");
        FileWriter f = new FileWriter("OutFile.txt");
        out = new PrintWriter(f);
        for (int i = 0; i < SIZE; i++) {
            out.println("Value at: " + i + " = " + list.get(i));
        }
    }
    catch and finally blocks  . . .
}

Pruebe las notas al margen del bloque

• Junto con el código que podría desencadenar una excepción, los bloques de prueba también pueden (pero no tienen que) contener código que no provoque excepciones.
• Los programas pueden contener más de un bloque de prueba. Además, es posible tener un bloque de prueba dentro de otro bloque de prueba.

Bloques de captura

La última mitad de un bloque try/catch es el bloque catch. Mientras que los bloques de prueba contienen código que provoca una excepción, los bloques de captura contienen el código que maneja una excepción.

En Java, el bloque catch se usa para manejar la excepción que se captura del bloque try. El bloque catch incluye el código y se ejecuta si ocurre una excepción dentro del bloque try. Si el sistema encuentra una excepción al ejecutar las declaraciones en un bloque de prueba, omite el resto de las declaraciones y transfiere el control al bloque catch correspondiente.

El bloque catch captura y maneja las excepciones del bloque try declarando el tipo de excepción dentro del parámetro. La excepción declarada en el bloque catch debe ser la excepción de clase principal (es decir, Excepción) o el tipo de excepción generado. Sin embargo, el mejor enfoque es declarar el tipo de excepción generado.

El bloque catch siempre seguirá después del bloque try. Una vez que el control sale del bloque de prueba, no hay forma de volver a colocarlo en el bloque de prueba.

Sintaxis

Los controladores de excepciones se asocian con un bloque de prueba al proporcionar uno o más bloques de captura directamente después del bloque de prueba . Ningún código puede estar entre el final del bloque try y el comienzo del primer bloque catch .

try {
  
} catch (ExceptionType name) {

}

El bloque catch contiene código que se ejecuta siempre y cuando se invoque el controlador de excepciones. El sistema de tiempo de ejecución invoca el controlador de excepciones cuando el controlador es el primero en la pila de llamadas cuyo ExceptionType coincide con el tipo de excepción lanzada. El sistema considera una coincidencia si el objeto arrojado se puede asignar legalmente al argumento del controlador de excepciones.

Argumentos de bloque de captura

Los bloques Catch toman un argumento, el tipo de excepción que se supone que deben capturar (manejar). Estos argumentos pueden variar desde un tipo de excepción muy específico hasta una categoría de excepciones muy general.

Ejemplo

Los siguientes son dos controladores de excepciones para el método writeList :

try {

} catch (IndexOutOfBoundsException e) {
    System.err.println("IndexOutOfBoundsException: " + e.getMessage());
} catch (IOException e) {
    System.err.println("Caught IOException: " + e.getMessage());
}

Contenido del bloque de captura

El contenido de un bloque catch es lo que desea que suceda cuando ocurre una excepción (por ejemplo, cuando el archivo al que se accede no existe). Puede imprimir un mensaje o tener un código que haga algo para corregir el error (por ejemplo, solicitar el nombre de archivo de nuevo.

Capturar mensajes de bloque (mostrar una descripción de una excepción)

Puede imprimir cualquier mensaje que desee dentro de un bloque catch.

Usando toString()

Throwable anula el método toString() (definido por Object) para que devuelva una cadena que contenga una descripción de la excepción. Puede mostrar esta descripción en una instrucción println() simplemente pasando la excepción como argumento. Por ejemplo, el bloque catch del programa anterior se puede reescribir así

catch (ArithmeticException e) {
    System.out.println("Exception: " + e);
    a = 0; // set a to zero and continue
  }

Exception: java.lang.ArithmeticException: / by zero

• getMessage() : devuelve un mensaje de error específico para cada tipo de excepción. Combine esto con una instrucción println.
• printStackTrace() : imprime el tipo de error y dónde ocurrió en el programa. Estos métodos son especialmente útiles para depurar y encontrar el motivo de una excepción.

• Cada bloque de prueba necesita al menos un bloque de captura.
• Los bloques Try pueden tener varios bloques catch. Vea el ejemplo de la derecha.
• Los bloques Catch deben ir directamente después del bloque Try con el que están emparejados.

finalmente bloques

Una palabra clave finalmente se utiliza para crear un bloque de código que sigue a un bloque de prueba. Un bloque de código finalmente siempre se ejecuta ya sea que haya ocurrido una excepción o no. Usando un bloque finalmente, le permite ejecutar cualquier declaración de tipo de limpieza que desee ejecutar, sin importar lo que suceda en el código protegido. Aparece un bloque finalmente al final del bloque catch. finalmente, los bloques se utilizan para anular las referencias de objetos y cerrar los flujos de E/S.

El bloque "finally " siempre se ejecuta cuando finaliza el bloque "try" . Esto asegura que el bloque finalmente se ejecute incluso si ocurre una excepción inesperada. Pero finalmente es útil para algo más que el manejo de excepciones: permite al programador evitar que el código de limpieza se pase por alto accidentalmente por return , continue o break . Poner el código de limpieza en un bloque finalmente es siempre una buena práctica, incluso cuando no se prevén excepciones.

El sistema de tiempo de ejecución siempre ejecuta las declaraciones dentro del bloque finalmente , independientemente de lo que suceda dentro del bloque de prueba . Así que es el lugar perfecto para realizar la limpieza.

Sintaxis

finally {
  // cleanup code
  }

El siguiente bloque finalmente para el método writeList limpia y luego cierra PrintWriter y FileWriter .

finally {
    if (out != null) { 
        System.out.println("Closing PrintWriter");
        out.close(); 
    } else { 
        System.out.println("PrintWriter not open");
    } 
    if (f != null) {
	    System.out.println("Closing FileWriter");
	    f.close();
	}	
}

• Finalmente, los bloques son una adición opcional a los bloques try/catch.
• Finalmente, los bloques se usan para el código que desea que se ejecute sin importar lo que suceda excepcionalmente con su código.
• Son lo último que se ejecuta y se ejecutarán cada vez que ejecute su programa.
• Un uso de un bloque finalmente sería asegurarse de que un archivo se cierre al final de un programa.

private List<Integer> list;
private static final int SIZE = 10;

public void writeList() {
    PrintWriter out = null;
    try {
        System.out.println("Entered try statement");
        FileWriter f = new FileWriter("OutFile.txt");
        out = new PrintWriter(f);
        for (int i = 0; i < SIZE; i++) {
            out.println("Value at: " + i + " = " + list.get(i));
        }
    } 
    // catch blocks
    catch (IndexOutOfBoundsException e) {
        System.err.println("IndexOutOfBoundsException: " + e.getMessage());
    } 
    catch (IOException e) {
        System.err.println("Caught IOException: " + e.getMessage());
    }
    // finally block
  finally {
    if (out != null) { 
        System.out.println("Closing PrintWriter");
        out.close(); 
    } else { 
        System.out.println("PrintWriter not open");
    } 
    if (f != null) {
     System.out.println("Closing FileWriter");
     f.close();
 } 
}
}

Cuando se utilizan bloques de prueba anidados , el bloque de prueba interno se ejecuta primero. Cualquier excepción lanzada en el bloque try interno se captura en el bloque catch correspondiente. Si no se encuentra un bloque catch coincidente, se inspecciona el bloque catch del bloque try externo . Este proceso continúa hasta que se agotan todas las sentencias de prueba anidadas. Si no se encuentra ningún bloque catch coincidente, el programa finaliza de manera anormal.

Visite el bloque try-catch anidado .

Captura múltiples excepciones

Como sabrá, en Java podemos usar múltiples bloques catch para manejar múltiples excepciones

Ejemplo :

catch (IOException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
catch (SQLException ex) {
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

Ejemplo :

catch(IOException | SQLException ex){
     logger.error(ex);
     throw new MyException(ex.getMessage());
}

Feliz aprendizaje

Únete al grupo de WhatsApp de Mouad Oumous Java ÚNETE

Únete al canal Mouad Oumous Telegram ÚNETE

Apoya nuestra publicación siguiéndola

Primeros pasos con Spring Boot: un tutorial completo para principiantes Spring Boot Security | inicio de sesión único | OAuth2 con Okta La pregunta de entrevista más frecuente basada en transmisión de Java8: Parte 2 Guía para la asignación de objetos con ModelMapper en Java Codificación: aplanar una matriz en Javascript La pregunta de entrevista más frecuente basada en transmisión de Java8: Parte 1