A Java, el maneig d'excepcions és un dels mitjans eficaços per gestionar els errors en temps d'execució de manera que es pugui preservar el flux normal de l'aplicació. Gestiona errors en temps d'execució com ara NullPointerException ArrayIndexOutOfBoundsException, etc. Per gestionar aquests errors amb eficàcia, Java proporciona dues paraules clau throw i throws.

Llançament de Java

La paraula clau throw a Java s'utilitza per llançar explícitament una excepció d'un mètode o qualsevol bloc de codi. Podem llançar excepcions marcades o no marcades. La paraula clau throw s'utilitza principalment per llançar excepcions personalitzades. 

Sintaxi:

llançar Instància

On la instància és un objecte del tipus Throwable (o les seves subclasses com Exception).

Exemple:

llança una nova ArithmeticException('/ per zero');

Però aquesta excepció, és a dir, la instància ha de ser del tipus Llançable o una subclasse de Llançable . 

El flux d'execució del programa s'atura immediatament després d'executar la instrucció throw i el tancament més proper. provar es comprova el bloc per veure si té un agafar declaració que coincideixi amb el tipus d'excepció. Si troba una coincidència controlada, es transfereix a aquesta declaració, en cas contrari, s'adjunta a continuació provar el bloc està marcat i així successivament. Si no coincideix agafar es troba, llavors el controlador d'excepcions predeterminat aturarà el programa. 

paraula clau estàtica en java

Exemple: Aquest exemple demostra on es llança una excepció atrapada i tornada a llançar-se dins d'un mètode.

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ó: L'exemple anterior demostra l'ús de la paraula clau throw per llançar explícitament una NullPointerException. L'excepció està atrapada dins del diversió () mètode i es torna a llançar on després queda atrapat al mètode main().

Exemple: Aquest exemple demostra una excepció 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);  }  } } 

Sortida:

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

Explicació: L'exemple anterior mostra una excepció amb throw on una ArithmeticException es llança explícitament a causa de la divisió per zero.

Llançaments de Java

llançaments és una paraula clau en Java que s'utilitza en la signatura d'un mètode per indicar que aquest mètode pot llançar una de les excepcions de tipus enumerades. La persona que truca a aquests mètodes ha de gestionar l'excepció mitjançant un bloc try-catch. 

Sintaxi:

escriviu nom_metode (paràmetres) llança exception_list

on exception_list és una llista separada per comes de totes les excepcions que pot generar un mètode.

En un programa, si hi ha la possibilitat de generar una excepció, el compilador sempre ens avisa sobre això i hem de gestionar aquesta excepció verificada En cas contrari, obtindrem un error de compilació que diu que l'excepció XXX no informada s'ha d'atrapar o declarar que s'ha de llançar. Per evitar aquest error de temps de compilació, podem gestionar l'excepció de dues maneres: 

1. Mitjançant l'ús try catch
2. Mitjançant l'ús de llançaments paraula clau

Podem utilitzar la paraula clau throws per delegar la responsabilitat del maneig d'excepcions a la persona que truca (pot ser un mètode o JVM), llavors el mètode de la trucada és responsable de gestionar aquesta excepció.  

Exemple 1: excepció no gestionada

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

Sortida:

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

Explicació: Al programa anterior, estem rebent un error de temps de compilació perquè hi ha una possibilitat d'excepció si el fil principal s'endormirà, altres fils tenen l'oportunitat d'executar el mètode main() que provocarà InterruptedException. 

Exemple 2: Ús throws per gestionar l'excepció

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

Sortida:

Hello Geeks

Explicació: Al programa anterior utilitzant la paraula clau throws vam gestionar InterruptedException i obtindrem la sortida com Hola Geeks.

Exemple 3: Llançar una excepció ambthrows

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ó: L'exemple anterior llança una IllegalAccessException des d'un mètode i la gestiona al mètode principal mitjançant un bloc try-catch.

convertir char a int java

Diferència entre llançament i llançament

Les principals diferències entre llançament i llançament a Java són les següents: