Prueba de Java: captura

Pueden ocurrir errores durante la ejecución del programa. Es un problema común para todos los programadores, desde principiantes hasta verdaderos profesionales. No todos los errores surgen por culpa del desarrollador. Algunos de ellos son difíciles de predecir y otras veces no es posible. Por ejemplo, mientras descarga un programa, la conexión de red puede caer repentinamente o puede cortarse la energía. Estas situaciones se denominan excepciones. Try y catch son las partes de la construcción que se utilizan para manejar excepciones.

Bloque de intento y captura de Java

Cuando ocurre un error, Java generalmente se detiene y genera un mensaje de error. Este proceso se llama "Java lanza una excepción". Java proporciona funciones especiales para manejar excepciones. Uno de ellos es intentar... atrapar... finalmente la construcción. Aquí está la sintaxis de try block, catch block y finalmente block.

//try block
try {
  // Block of code to try
}
//try catch 
catch(Exception e) {
  // Block of code to handle errors
}
finally {
 // Optional block of code 
          }

Cuando ocurre una excepción en el bloque try, el control pasa al bloque catch, que puede manejar la excepción. Si no se encuentra dicho bloque, se muestra al usuario un mensaje de excepción no controlada y se detiene la ejecución adicional del programa. Para evitar una parada de emergencia de este tipo es necesario utilizar el bloque try..catch.

Brevemente sobre intentar, atrapar y finalmente arrojar palabras clave

El manejo de excepciones en Java se basa en el uso de las siguientes palabras clave en un programa:

• try: define un bloque de código en el que puede ocurrir una excepción;
• catch: define el bloque de código en el que se maneja la excepción;
• finalmente: define un bloque de código que es opcional, pero si está presente, se ejecuta de todos modos, independientemente de los resultados del bloque try.

Estas palabras clave se utilizan para crear construcciones de procesamiento especiales en el código del programa: try catch e try catch finalmente}.

• throw: usado para generar una excepción;
• throws: se utiliza en firmas de métodos para advertir que un método podría generar una excepción.

Ejemplo sencillo de construcción try-catch

Digamos que tenemos un programa con alguna matriz.

public class TryTest {
   public static void main(String[] args) {
       int[] myArray = new int[5];
       myArray[7] = 8;
       System.out.println(myArray[7]);
   }
}

Como estamos intentando acceder a un elemento de la matriz con un índice inexistente, el programa saldrá con un error: Modifiquemos este programa y manejemos esta excepción con un try-catch. Primero viene el bloque de prueba, luego el bloque de captura.

//try catch example
public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {
           System.out.println("The exception was handled...");
       }

       System.out.println("This is the end of the program...");
   }
}

Ahora la salida ha cambiado: En este caso, el programa se completó correctamente, nuestro mensaje se muestra en la pantalla. La finalización correcta del programa se indica con el código 0 al final del proceso, mientras que la incorrecta es 1. Cuando se utiliza un bloque try...catch, todas las declaraciones entre las declaraciones try y catch se ejecutan primero. Si ocurre una excepción en el bloque try, entonces la orden de ejecución normal se detiene y continúa con la declaración catch. Por lo tanto, cuando la ejecución del programa alcanza los números[7]=8; línea, el programa se detendrá e irá al bloque catch. En nuestro caso, hemos declarado la variable myEx con el tipo Exception. Esta es la clase base para todas las excepciones y, por lo tanto, pueden ser diferentes. Por ejemplo, hay excepciones que son responsables de los desbordamientos de la pila, yendo más allá de la indexación de la matriz, como en nuestro caso, que apuntan a Null, etc. Si no hubiéramos adivinado el tipo de excepción, el programa también habría finalizado incorrectamente. Sin embargo, elegimos el tipo Exception para simplificar el ejemplo, y es la clase base para todas las excepciones. Entonces la declaración catch (Exception myEx) manejará casi todas las excepciones. Manejo de la excepción en este caso Una vez que se completa el bloque catch, el programa continúa su trabajo y ejecuta todas las demás instrucciones después del bloque catch. Si desea ver las excepciones ocurridas, puede hacer que el programa imprima un seguimiento de la pila de llamadas a métodos. Esto es lo que hace la JVM cuando ocurre una excepción no detectada: detiene la ejecución del programa e imprime un seguimiento de la pila después de ejecutar el código del bloque finalmente, si está presente.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {
          
         myEx.printStackTrace();
       }

       System.out.println("This is the end of the program...");
   }
}

Manejar la excepción en este caso se reduce a imprimir la pila de seguimiento de errores en la consola usando el método printStackTrace() definido en la clase Exception . Sin embargo, el programa salió correctamente.

¡Finalmente! despues de atrapar

En el ejemplo y en las definiciones de las palabras clave para el manejo de excepciones, mencionamos el bloque finalmente. Es opcional, pero si está presente, se ejecutará independientemente de los resultados del bloque try. Cambiemos el tipo de excepción a NullPointerException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (NullPointerException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

Aquí está el resultado: Por cierto, podemos especificar que el tipo de excepción sea correcto. Aquí está IndexOutOfBoundsException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (IndexOutOfBoundsException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

En este caso, la salida será la siguiente:

¿Cómo funcionan las excepciones?

El punto es que todas estas palabras (catch, throw, throws) solo se pueden usar con java.lang.Throwable o sus descendientes. Por ejemplo, puedes hacer esto:

public class MyClass {
    public static void main(String[] args) {
        try {
        } catch (Throwable thr) {
}
    }
}

Sin embargo, no puedes hacerlo así:

public class MyClass {
public static void main(String[] args) {
        try {
        } catch (String thr) {
}
    }
}