Lance un mot-clé en Java

Java throws est un mot-clé qui est déclaré avec le nom de la méthode, avec l'exception, le nom de la méthode est susceptible d'être déclenché lors de son appel. La déclaration d'un mot-clé facilite la gestion des exceptions et permet au compilateur de savoir que la méthode particulière lève une exception vérifiée, qui doit être déclarée au moment de la compilation, telle que IOException ou ClassNotFoundException. Si l'on ne gère pas une exception vérifiée à l'aide d'un bloc try-catch ou si l'on lance un mot-clé, le compilateur génère une erreur de compilation. Ce mot-clé aide également le programmeur à développer une application efficace en sachant que la méthode lève une exception.

Syntaxe :

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Access_specifierreturn_typemethod_namethrowsexception_name

Ici,

• Access_specifier : il s'agit du mot-clé qui indique à JVM à partir duquel la méthode particulière est accessible. Par exemple, privé/public ou protégé.
• Return_type : il s'agit du mot-clé qui indique le type de données de l'objet renvoyé par la méthode appelée, par exemple, int, Boolean, String, etc.
• Nom_méthode : Il s'agit du nom de la méthode qui doit être appelée.
• exception_name peut être une exception intégrée ou personnalisée que le processus est susceptible de déclencher lors de l'exécution du flux du programme.

Exemple :

public void my_method() throws MyException

Comment fonctionne le mot-clé Throws en Java ?

Les erreurs et les exceptions sont d'une grande importance pour une application Java. Cela permet de déterminer si quelque chose d'inapproprié s'est produit, comme une erreur de syntaxe ou une entrée saisie ne correspond pas aux données. En outre, les erreurs sont inévitables et conduisent simplement à des erreurs de compilation et à l’arrêt imprévisible de l’exécution de l’application ; les exceptions peuvent être gérées dans une certaine mesure.

Gérer une exception signifie que si elle se produit, comment arrêter l'exécution de manière correcte et décidée.

Il existe deux types d'exceptions :

• Exception non vérifiée : ces types d'exceptions sont des exceptions d'exécution qui ne sont pas vérifiées par le compilateur si elles sont gérées dans le code. Exemple : exception arithmétique, IndexOutOfBoundsException, etc. Utiliser le mot-clé throws pour ces exceptions n'a aucun sens.
• Exception vérifiée : ce sont les types d'exceptions que le compilateur vérifie au moment de la compilation pour voir si elles sont gérées ou non. Ainsi, si celles-ci ne sont pas gérées, le compilateur renvoie l’erreur – Type d’exception non gérée. Exemple – IOException, ClassNotFoundException.

Deux façons de gérer

Ainsi, il existe deux manières de gérer une exception vérifiée :

1. Essayez-attrapez

En utilisant try-catch, on place les instructions qui pourraient déclencher une exception dans un bloc try, et si une exception est levée, le contrôle passe aux instructions du bloc catch pour les exécuter. De cette façon, nous pouvons contrôler le flux de l’application lorsqu’une exception se produit.

Code :

//package Proc;
class MyCustomeException extends Throwable{
MyCustomeException(String s){
super(s);
}
}
public class prac1
{
public static void main(String[] args)    {
try{
System.out.println("Now exception is being raised");
throw new MyCustomeException("Custom exception is thrown");
}
catch(MyCustomeException e){
System.out.println("Here exception is caught and handled");
}
}
}

Sortie :

Explication : Dans l'exemple ci-dessus, nous avons déclaré une exception personnalisée et l'avons lancée explicitement dans la méthode main à l'aide du mot-clé throw. Une fois que le contrôle entre dans le contrôle de méthode et lève une exception, il accède directement au bloc catch, exécute ces instructions et quitte le programme.

2. Lance un mot-clé

Déclarer ce mot-clé avec le nom de la méthode indique au compilateur que la méthode peut lever une exception. Ce mot-clé est généralement confondu avec le mot-clé throw, utilisé pour lever volontairement une exception dans notre code ou lorsque vous travaillez avec des exceptions personnalisées.

• Lance des mots-clés uniquement nous permet d'exécuter les instructions au cas où une exception se produirait. Il ne peut pas être utilisé pour éviter l’apparition d’une exception. Ainsi, il est utilisé pour la gestion des exceptions.
• Le mot-clé throws est souvent confondu avec un throw, utilisé pour lancer explicitement une exception. Et les lancers servent à le gérer.
• Si une exception se produit, les mots-clés de ligne aident les programmeurs à faire fonctionner le programme de manière fluide et efficace.

Exemples d'implémentation du mot-clé Throws en Java

Nous pouvons utiliser le mot-clé throws de 2 manières :

Exemple n°1

Tout d'abord, nous pouvons utiliser des lancers dans la déclaration de la méthode où une exception est levée.

Code :

//package Proc;
public class prac1
{
public static void main(String[] args)throws IllegalAccessException
{
System.out.println("Hello Everyone lets start our learning with throws keyword");
throw new IllegalAccessException("My Exception");
}
}

Sortie :

Explanation: In the above example, we have used the throws keyword to handle the exception being thrown using the throw keyword. In case an exception is raised, it will not prevent the program’s abnormal termination; instead, it helps to convince the compiler. Also, it helps to inform the programmer that the method might throw an exception and needs exception handling.

Example #2

Second, we use a try-catch block while calling a method that is likely to throw an exception. We have made a custom exception here named MyCustomeException that is being thrown by the method throwsDemo.

Code:

//package Proc;
class MyCustomeException extends Throwable{
MyCustomeException(String s){
super(s);
}
}
public class prac1
{
static void throwsDemo() throws MyCustomeException
{
System.out.println("We are Inside the method");
throw new MyCustomeException("Custom exception is thrown");
}
public static void main(String[] args)throws IllegalAccessException
{
try{
System.out.println("Now exception is being raised");
throwsDemo();
}
catch(MyCustomeException e){
System.out.println("Here exception is caught and handled");
}
}
}

Output:

Explanation: In the above example, one method throws a new exception. This is indicated using the throws keyword. But when the method is called in the main method, we can use a try-catch block or declaring a throws keyword with the main method to handle the exception.

Conclusion

Throws keyword is used for exception handling in Java, where one needs to handle the flow of the program when a checked exception occurs. This is different from the throw keyword and must only be used with the checked exception since it does not prevent the occurrence of an exception but helps the way that must execute if one occurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!