Le Java lance un mot-clé est utilisé pour déclarer une exception. Il informe le programmeur qu'une exception peut se produire. Il est donc préférable que le programmeur fournisse le code de gestion des exceptions afin que le déroulement normal du programme puisse être maintenu.

La gestion des exceptions est principalement utilisée pour gérer les exceptions vérifiées. S'il se produit une exception non vérifiée telle que NullPointerException, c'est la faute du programmeur s'il ne vérifie pas le code avant de l'utiliser.

emojis iphone sur android

Syntaxe des lancers Java

 return_type method_name() throws exception_class_name{ //method code } 

Quelle exception déclarer ?

Ans: Exception vérifiée uniquement, car :

exception non vérifiée :sous notre contrôle afin que nous puissions corriger notre code.erreur:au-delà de notre contrôle. Par exemple, nous ne pouvons rien faire en cas d'erreur VirtualMachineError ou StackOverflowError.

L'avantage de Java lance un mot clé

L’exception vérifiée peut désormais être propagée (transférée dans la pile d’appels).

Il fournit des informations à l'appelant de la méthode sur l'exception.

Java lance un exemple

Voyons l'exemple de la clause Java throws qui décrit que les exceptions vérifiées peuvent être propagées par le mot-clé throws.

Testthrows1.java

 import java.io.IOException; class Testthrows1{ void m()throws IOException{ throw new IOException('device error');//checked exception } void n()throws IOException{ m(); } void p(){ try{ n(); }catch(Exception e){System.out.println('exception handled');} } public static void main(String args[]){ Testthrows1 obj=new Testthrows1(); obj.p(); System.out.println('normal flow...'); } } 

Sortir:

comparaison de chaînes Java

 exception handled normal flow... 

Règle : si nous appelons une méthode qui déclare une exception, nous devons soit intercepter, soit déclarer l'exception.

Il y a deux cas :

Cas 1:Nous avons détecté l'exception, c'est-à-dire que nous avons géré l'exception à l'aide du bloc try/catch.Cas 2 :Nous avons déclaré l'exception, c'est-à-dire le mot-clé throws spécifié avec la méthode.

Cas 1 : gérer l'exception à l'aide du bloc try-catch

Dans le cas où nous traitons l'exception, le code sera exécuté correctement, que l'exception se produise ou non pendant le programme.

Testthrows2.java

 import java.io.*; class M{ void method()throws IOException{ throw new IOException('device error'); } } public class Testthrows2{ public static void main(String args[]){ try{ M m=new M(); m.method(); }catch(Exception e){System.out.println('exception handled');} System.out.println('normal flow...'); } } 

Sortir:

 exception handled normal flow... 

Cas 2 : déclarer une exception

• Dans le cas où nous déclarons l'exception, si l'exception ne se produit pas, le code sera exécuté correctement.
• Dans le cas où nous déclarons l'exception et qu'elle se produit, elle sera levée au moment de l'exécution car jette ne gère pas l'exception.

Voyons des exemples pour les deux scénarios.

qu'est-ce qu'un hashset en Java

A) Si aucune exception ne se produit

Testthrows3.java

 import java.io.*; class M{ void method()throws IOException{ System.out.println('device operation performed'); } } class Testthrows3{ public static void main(String args[])throws IOException{//declare exception M m=new M(); m.method(); System.out.println('normal flow...'); } } 

Sortir:

 device operation performed normal flow... 

B) En cas d'exception

Testthrows4.java

 import java.io.*; class M{ void method()throws IOException{ throw new IOException('device error'); } } class Testthrows4{ public static void main(String args[])throws IOException{//declare exception M m=new M(); m.method(); System.out.println('normal flow...'); } } 

Sortir:

Différence entre lancer et lancers

Que) Pouvons-nous relancer une exception ?

Oui, en lançant la même exception dans le bloc catch.