En Java, la gestion des exceptions est l'un des moyens efficaces de gérer les erreurs d'exécution afin que le flux régulier de l'application puisse être préservé. Il gère les erreurs d'exécution telles que NullPointerException ArrayIndexOutOfBoundsException, etc. Pour gérer efficacement ces erreurs, Java fournit deux mots-clés throw et throws.

Lancement Java

Le mot-clé throw en Java est utilisé pour lever explicitement une exception à partir d'une méthode ou de n'importe quel bloc de code. Nous pouvons lancer une exception cochée ou non cochée. Le mot-clé throw est principalement utilisé pour lancer des exceptions personnalisées. 

Syntaxe:

lancer Exemple

Où instance est un objet de type Throwable (ou ses sous-classes telles que Exception).

Exemple:

throw new ArithmeticException('/ par zéro');

Mais cette exception, c'est-à-dire l'instance, doit être de type Jetable ou une sous-classe de Jetable . 

Le flux d'exécution du programme s'arrête immédiatement après l'exécution de l'instruction throw et l'encadrant le plus proche essayer le bloc est vérifié pour voir s'il a un attraper instruction qui correspond au type d’exception. S'il trouve une correspondance contrôlée, il est transféré à cette instruction, sinon la prochaine pièce jointe essayer le bloc est vérifié et ainsi de suite. Si aucune correspondance attraper est trouvé, le gestionnaire d'exceptions par défaut arrêtera le programme. 

quelque chose de rapide

Exemple: Cet exemple montre où une exception est levée, interceptée et renvoyée dans une méthode.

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. 

Explication: L'exemple ci-dessus montre l'utilisation du mot-clé throw pour lancer explicitement une NullPointerException. L'exception est capturée à l'intérieur du amusant() et renvoyé là où il est ensuite capturé dans la méthode main().

Exemple: Cet exemple illustre une exception arithmétique.

// 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);  }  } } 

Sortir:

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

Explication: L'exemple ci-dessus montre une exception utilisant throw où une ArithmeticException est explicitement levée en raison d'une division par zéro.

Java lance

jette est un mot-clé en Java utilisé dans la signature d'une méthode pour indiquer que cette méthode peut lever l'une des exceptions de type répertoriées. L'appelant de ces méthodes doit gérer l'exception à l'aide d'un bloc try-catch. 

Syntaxe:

tapez nom_méthode (paramètres) et lance une liste d'exceptions

où exception_list est une liste séparée par des virgules de toutes les exceptions qu'une méthode peut lever.

Dans un programme, s'il y a une chance de déclencher une exception, le compilateur nous en avertit toujours et nous devons gérer cette exception vérifiée. Sinon, nous obtiendrons une erreur de compilation indiquant que l'exception non signalée XXX doit être interceptée ou déclarée pour être levée. Pour éviter cette erreur de compilation, nous pouvons gérer l'exception de deux manières : 

1. En utilisant try catch
2. En utilisant le jette mot-clé

Nous pouvons utiliser le mot-clé throws pour déléguer la responsabilité de la gestion des exceptions à l'appelant (il peut s'agir d'une méthode ou d'une JVM), la méthode de l'appelant est alors responsable de gérer cette exception.  

Exemple 1 : exception non gérée

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

Sortir:

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

Explication: Dans le programme ci-dessus, nous obtenons une erreur de compilation car il y a un risque d'exception si le thread principal va dormir, d'autres threads ont la possibilité d'exécuter la méthode main() qui provoquera InterruptedException. 

Exemple 2 : Utilisation throws pour gérer les exceptions

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

Sortir:

Hello Geeks

Explication: Dans le programme ci-dessus, en utilisant le mot-clé throws, nous avons géré le Exception interrompue et nous obtiendrons le résultat sous la forme Bonjour les Geeks.

multithreading en Java

Exemple 3 : Lancer une exception avecthrows

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. 

Explication: L'exemple ci-dessus lance une IllegalAccessException à partir d'une méthode et la gère dans la méthode principale à l'aide d'un bloc try-catch.

Différence entre lancer et lancers

Les principales différences entre throw et throws en Java sont les suivantes :

touches de modification