En Java, el manejo de excepciones es uno de los medios eficaces para manejar los errores de tiempo de ejecución de modo que se pueda preservar el flujo normal de la aplicación. Maneja errores de tiempo de ejecución como NullPointerException ArrayIndexOutOfBoundsException, etc. Para manejar estos errores de manera efectiva, Java proporciona dos palabras clave throw y throws.

lanzamiento de java

La palabra clave throw en Java se utiliza para lanzar explícitamente una excepción desde un método o cualquier bloque de código. Podemos lanzar una excepción marcada o no marcada. La palabra clave throw se utiliza principalmente para generar excepciones personalizadas. 

Sintaxis:

tirar Instancia

Donde instancia es un objeto de tipo Throwable (o sus subclases como Exception).

Ejemplo:

lanzar nueva ArithmeticException('/ por cero');

Pero esta excepción, es decir, la instancia debe ser de tipo arrojable o una subclase de arrojable . 

El flujo de ejecución del programa se detiene inmediatamente después de que se ejecuta la instrucción throw y el adjunto más cercano intentar Se comprueba el bloque para ver si tiene un atrapar declaración que coincida con el tipo de excepción. Si encuentra una coincidencia controlada se transfiere a esa declaración, de lo contrario se adjunta a continuación intentar el bloque está marcado y así sucesivamente. Si no hay coincidencia atrapar se encuentra, el controlador de excepciones predeterminado detendrá el programa. 

función prototipo de c++

Ejemplo: Este ejemplo demuestra dónde se lanza una excepción, se captura y se vuelve a lanzar dentro de un método.

class Geeks {  static void fun()  {  try {  throw new NullPointerException('demo');  }  catch (NullPointerException e) {  System.out.println('Caught inside fun().');  throw e; // rethrowing the exception  }  }  public static void main(String args[])  {  try {  fun();  }  catch (NullPointerException e) {  System.out.println('Caught in main.');  }  } } 

Caught inside fun(). Caught in main. 

Explicación: El ejemplo anterior demuestra el uso de la palabra clave throw para lanzar explícitamente una NullPointerException. La excepción está atrapada dentro del divertido() método y se vuelve a lanzar donde luego queda atrapado en el método main().

Ejemplo: Este ejemplo demuestra una excepción aritmética.

// Throwing an arithmetic exception class Geeks {  public static void main(String[] args){  int numerator = 1;  int denominator = 0;  if (denominator == 0) {  // Manually throw an ArithmeticException  throw new ArithmeticException('Cannot divide by zero');  } else {  System.out.println(numerator / denominator);  }  } } 

Producción:

Hangup (SIGHUP)  
Exception in thread 'main' java.lang.ArithmeticException: Cannot divide by zero  
 at Geeks.main(Geeks.java:9)

Explicación: El ejemplo anterior demuestra una excepción usando throw donde se lanza explícitamente una ArithmeticException debido a la división por cero.

lanzamientos de Java

lanza es una palabra clave en Java que se utiliza en la firma de un método para indicar que este método podría generar una de las excepciones de tipo enumeradas. La persona que llama a estos métodos tiene que manejar la excepción utilizando un bloque try-catch. 

Sintaxis:

escriba nombre_método (parámetros) lanza lista_excepción

donde lista_excepciones es una lista separada por comas de todas las excepciones que puede generar un método.

En un programa, si existe la posibilidad de generar una excepción, el compilador siempre nos advierte sobre ello y debemos manejar esa excepción marcada. De lo contrario, obtendremos un error en tiempo de compilación que indica que la excepción XXX no reportada debe detectarse o declararse lanzada. Para evitar este error en tiempo de compilación, podemos manejar la excepción de dos maneras: 

1. Usando try catch
2. Al utilizar el lanza palabra clave

Podemos usar la palabra clave throws para delegar la responsabilidad del manejo de excepciones a la persona que llama (puede ser un método o JVM), luego el método de la persona que llama es responsable de manejar esa excepción.  

Ejemplo 1: excepción no controlada

agregar en matriz java

class Geeks {  public static void main(String[] args)  {  Thread.sleep(10000);  System.out.println('Hello Geeks');  } } 

Producción:

error: unreported exception InterruptedException; must be caught or declared to be thrown

Explicación: En el programa anterior, obtenemos un error de tiempo de compilación porque existe la posibilidad de que se produzca una excepción si el subproceso principal va a dormir, otros subprocesos tienen la oportunidad de ejecutar el método main(), lo que provocará una InterruptedException. 

Ejemplo 2: uso throws para manejar la excepción

class Geeks {  public static void main(String[] args)  throws InterruptedException  {  Thread.sleep(10000);  System.out.println('Hello Geeks');  } } 

Producción:

Hello Geeks

Explicación: En el programa anterior, usando la palabra clave throws manejamos el Excepción interrumpida y obtendremos el resultado como Hola frikis.

Ejemplo 3: Lanzar una excepción conthrows

class Geeks {  static void fun() throws IllegalAccessException  {  System.out.println('Inside fun(). ');  throw new IllegalAccessException('demo');  }  public static void main(String args[])  {  try {  fun();  }  catch (IllegalAccessException e) {  System.out.println('Caught in main.');  }  } } 

Inside fun(). Caught in main. 

Explicación: El ejemplo anterior arroja una IllegalAccessException desde un método y la maneja en el método principal usando un bloque try-catch.

Diferencia entre lanzamiento y lanzamientos

Las principales diferencias entre throw y throws en Java son las siguientes: