Excepción de lanzamiento de Java

Dondequiera que vayamos, nos esperan acontecimientos impredecibles. Terremotos, acciones irracionales de personas, meteoritos... o algo más simple: una bombilla se funde, una tarjeta bancaria se desmagnetiza, un indicador de gasolina se rompe. No podemos desactivar los acontecimientos impredecibles, pero al menos podemos estar parcialmente preparados para ellos. Es decir, debemos preparar ciertos mecanismos para hacerles frente. En el mundo de la programación, específicamente en el lenguaje Java, los eventos que impiden que un programa funcione normalmente se denominan excepciones y los mecanismos para evitar fallas del programa se denominan manejo de excepciones. Entonces, cuando ocurre un evento inesperado en un programa, como una división por cero, debería "lanzar" una excepción. El manejo de excepciones es un aspecto importante de la programación Java que ayuda a los desarrolladores a gestionar errores y excepciones que pueden ocurrir durante la ejecución de un programa. En este artículo, nos centraremos en uno de los conceptos fundamentales del manejo de excepciones: la palabra clave throw de Java y cómo usarla para generar una excepción.

¿Qué es una excepción en Java?

Una excepción es un evento que ocurre durante la ejecución de un programa y que interrumpe el flujo normal de las instrucciones del programa. Cuando ocurre una excepción, la ejecución del programa se detiene y el mensaje de error se muestra en la consola. En Java, existen dos tipos de excepciones: marcadas y no marcadas. Las excepciones marcadas se verifican en tiempo de compilación y el compilador se asegura de que sean capturadas o declaradas por el método de llamada. Por otro lado, las excepciones no comprobadas no se comprueban en tiempo de compilación y pueden detectarse o dejarse sin detectar. A continuación se muestra un ejemplo de código en el que puede producirse un error, pero el compilador lo omite.


public class Factorial {
   public static long getFactorial(final int number) {
           long fact = 1;
           for (int i = 1; i <= number; i++) {
               fact = fact * i;
           }
           return fact;
   }

   public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }

}

Aquí está el resultado del programa:

1 -4249290049419214848

El programa salió correctamente, pero produjo un resultado incorrecto. En el primer caso, porque el argumento de la función era negativo y el factorial no funciona para números negativos. En el segundo caso, el resultado fue incorrecto porque el número es demasiado grande para contar su factorial en el rango de tipo largo. Aquí hay otro ejemplo. Escribamos un programa en el que dividiremos un número por otro.


public class DivisionExample {

       public static void main(String[] args) {
           int a = 10;
           int b = 0;
           int result = divide(a, b);
           System.out.println(result);
       }

       public static int divide(int a, int b) {
           return a / b;
       }
}

En este ejemplo, se generará una excepción ArithmeticException porque la variable b es cero. Sin embargo, este error no se soluciona, por lo que el programa sale con un estado incorrecto.

Cómo lanzar una excepción en Java

En Java, las excepciones también son objetos, por lo que se genera una excepción como si se creara un nuevo objeto de excepción. Se lanza una excepción en un programa usando la declaración throw. Por lo general, estas dos operaciones (creación de objetos y lanzamiento de una excepción) se combinan en una:


 throw new Exception("error…");

La palabra clave throw en Java se utiliza para generar una excepción desde un método o bloque de código cuando ocurre un error o una condición excepcional que el programa no puede manejar en tiempo de ejecución. El flujo del programa se redirige al bloque catch más cercano. Este bloque puede gestionar la excepción.

Ejemplo del uso de la palabra clave "lanzar"

Para ilustrar la funcionalidad de la palabra clave throw en Java, tomemos un ejemplo. Escribamos un método para calcular el factorial de un número. Si el número es negativo, no se puede calcular, por lo que se debe generar una excepción. De manera similar, si el número es demasiado grande, el resultado factorial excederá el tamaño máximo de un tipo largo y se generará otra excepción. Aquí tenemos una implementación del método:


public Class Factorial {

public static long getFactorial(final int number) {
   if ((number >= 0) && (number < 21)) {
       long fact = 1;
       for (int i = 1; i <= number; i++) {
           fact = fact * i;
       }
       return fact;
   } else {

//throw new exception here 
       throw new IllegalArgumentException("THe argument isn't legal");
   }
}

 public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }
}

En este ejemplo, si el valor del número es negativo, la palabra clave throw se usa para generar una instancia de la clase IllegalArgumentException . Si ejecuta el programa, se mostrará el mensaje "El argumento no es legal" en la consola. La ejecución del programa se detendrá.

No más errores: captando un ejemplo de excepción

Ahora recordemos el segundo ejemplo, con división por cero, y ejecutémoslo con manejo de excepciones.


public class DivisionExample {

    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int result = divide(a, b);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Error: division by zero");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

En este ejemplo, agregamos una construcción try-catch para manejar la excepción de división por cero. En pocas palabras, try-catch-finally es una construcción del lenguaje de programación Java que le permite manejar excepciones y ejecutar código independientemente de si ocurrió una excepción o no. try-catch-finally consta de tres bloques:

El bloque de prueba . Aquí se está ejecutando código potencialmente peligroso. Ese es un código que puede generar una excepción. Si se produce una excepción dentro de un bloque try , se cancela la ejecución del código en ese bloque y el control se transfiere al bloque catch.
El bloque de captura . Aquí se maneja la excepción lanzada. En el bloque catch , puede especificar qué excepción capturar y qué lógica ejecutar cuando se detecte.

final

finalmente

La construcción try-catch-finally permite un control más preciso sobre la ejecución del programa en caso de situaciones excepcionales y ayuda a evitar la terminación inesperada del programa en caso de errores. Ahora, volvamos a nuestro ejemplo. Si se produce una división por cero durante el método de división, se generará una ArithmeticException , que es capturada por el bloque catch. En el bloque catch , simplemente imprimimos un mensaje de error en la consola. Si no ocurre ninguna excepción, el programa continuará su ejecución.

lanza palabra clave

La palabra clave throws se utiliza en la firma del método. Si es así, significa que se está lanzando una excepción en el método. Esto puede propagar excepciones en la pila de llamadas e indicar que no es necesario manejar las excepciones en el método actual. En Java, "lanzamientos" también se pueden utilizar para referirse a excepciones personalizadas definidas en un programa. Por ejemplo, un método puede realizar una división de dos números pero generar una excepción IllegalArgumentException si el segundo argumento es cero:


public static double divide(double a, double b) throws IllegalArgumentException {
    if (b == 0) {
        throw new IllegalArgumentException("Division by zero is not allowed");
    }
    return a / b;
}

Este método utiliza la palabra clave throws para indicar que se puede lanzar una excepción IllegalArgumentException si el segundo argumento es nulo. Si se produce una excepción de este tipo durante la ejecución del método, se pasará al método que llama para su procesamiento. Ejemplo de llamada a método:


public static void main(String[] args) {
    double result = 0;
    try {
        result = divide(10, 0);
    } catch (IllegalArgumentException e) {
        System.out.println("Error: " + e.getMessage());
    }
    System.out.println("Result: " + result);
}

En este ejemplo, se llama al método divide() con los argumentos 10 y 0, lo que generará una IllegalArgumentException debido a que la división por cero es imposible. La excepción será detectada por un bloque try-catch y se mostrará un mensaje de error. El programa dará como resultado un valor de cero ya que la excepción finaliza la ejecución del método divide() .