Comment lancer une exception en Java
Le mot clé throw en Java est utilisé pour lever une exception explicitement. L'objet d'exception qui est levé est spécifié. L'exception est accompagnée d'un message qui décrit l'erreur. Ces erreurs peuvent être entièrement causées par les entrées de l'utilisateur, le serveur ou autre chose.
En Java, le mot clé throw est utilisé pour lever une exception à partir d'une méthode ou de tout autre morceau de code. La levée d'exceptions personnalisées est l'utilisation la plus courante du mot clé throw. Nous avons la possibilité de lever une exception cochée ou non cochée.
Si nous divisons un nombre par un autre nombre, nous pouvons lever une ArithmeticException. Tout d'abord, nous devons définir la condition et utiliser le mot-clé throw pour lever une exception. Nous pouvons également utiliser le mot clé throw pour établir nos circonstances et lancer explicitement des exceptions.
Lancer Java
La syntaxe est la suivante :
throw Instance
Exemple :
throw new ArithmeticException("/ by zero"); Cependant, Instance doit être de type Throwable ou une sous-classe de Throwable dans ce cas. En effet, les exceptions définies par l'utilisateur étendent souvent la classe Exception, une sous-classe Throwable. Contrairement à C++, les types de données tels que les classes int, char, float et non-throwable ne peuvent pas être utilisés comme exceptions.
Le flux d'exécution du programme s'arrête immédiatement après l'exécution de l'instruction throw. Le bloc try englobant le plus proche est examiné pour une instruction catch qui correspond au type d'exception. Si une correspondance est trouvée, le contrôle est passé à cette instruction. Sinon, le prochain bloc try englobant est examiné, et ainsi de suite. Le gestionnaire d'exceptions par défaut mettra fin à l'application si aucun catch correspondant n'est trouvé.
// program demonstrating the use of throw
class ThrowExcep
{
static void play()
{
try
{
throw new NullPointerException("trial");
}
catch(NullPointerException e)
{
System.out.println("Caught inside play().");
throw e; // rethrowing the exception
}
}
public static void main(String args[])
{
try
{
play();
}
catch(NullPointerException e)
{
System.out.println("Caught in the main method");
}
}
} }
Exemple :lancer
// program demonstrating how to use throw
class throwTest
{
public static void main(String[] args)
{
System.out.println(1/0);
}
} lance
En Java, le terme throws est utilisé dans la signature de la méthode pour indiquer que la méthode peut lever l'une des exceptions de type données. Par conséquent, l'appelant de ces méthodes doit utiliser un bloc try-catch pour gérer l'exception.
La syntaxe est la suivante :
type method_name(parameters) throws exception_list
Une liste d'exceptions est une liste séparée par des virgules de toutes les exceptions possibles levées par une méthode. S'il y a une chance de lever une exception dans un programme, le compilateur nous en avertira toujours, et nous devons gérer cette exception vérifiée. Sinon, nous recevrons un avertissement au moment de la compilation indiquant que l'exception non signalée XXX doit être interceptée ou déclarée être levée. Nous pouvons gérer l'exception de deux manières pour éviter cette erreur de compilation :
- Utilisation de la méthode try-catch
- Utilisation du mot-clé throws
Nous pouvons utiliser le mot clé throws pour déléguer la gestion des exceptions à l'appelant (qui peut être une méthode ou une JVM), puis la méthode de l'appelant est responsable de la gestion de l'exception.
// program illustrating the error in case
// of unhandled exception
class testError
{
public static void main(String[] args)
{
Thread.sleep(10000);
System.out.println("Codeunderscored");
}
}
Dans l'application précédente, nous obtenons une erreur de temps de compilation car si le thread principal se met en veille, d'autres threads auront la possibilité d'exécuter la méthode main(), ce qui entraînera une InterruptedException.
// program illustrating how throws functions
class testError
{
public static void main(String[] args)throws InterruptedException
{
Thread.sleep(10000);
System.out.println("Codeunderscored");
}
} Nous avons géré InterruptedException dans le programme suivant en utilisant le mot-clé throws, et la sortie est Codeunderscored.
Exemple :démonstration du fonctionnement des lancers
class demoThrowsExecp
{
static void play() throws IllegalAccessException
{
System.out.println("Inside play(). ");
throw new IllegalAccessException("demonstrating Throws exception");
}
public static void main(String args[])
{
try
{
play();
}
catch(IllegalAccessException e)
{
System.out.println("caught in main method.");
}
}
} Éléments essentiels à garder à l'esprit lors de l'utilisation du mot clé "lance" :
- Le mot clé throws n'est requis que pour les exceptions vérifiées ; il est inutile de l'utiliser pour des exceptions non contrôlées.
- Le mot clé throws est juste nécessaire pour persuader le compilateur ; cela n'empêche pas l'arrêt anormal du programme.
- Nous pouvons offrir des détails sur l'exception à l'appelant de la méthode en utilisant le mot-clé throws.
Exemple :comment lancer une exception non vérifiée
classe publique testThrowUncheckedException {
public class testThrowUncheckedException {
//function to check if person is eligible to vote or not
public static void validate(int score) {
if(score<70) {
//throw Arithmetic exception if not eligible to vote
throw new ArithmeticException("Student cannot qualify for this course");
}
else {
System.out.println("Student qualifies to take this course!!");
}
}
//main method
public static void main(String args[]){
//trigger the function
validate(65);
System.out.println(" After primary code execution");
}
} Une exception non vérifiée est levée par le code ci-dessus. Nous pouvons également lancer des exceptions non contrôlées et définies par l'utilisateur de la même manière. Si une méthode lève une exception non vérifiée, elle doit être gérée ou déclarée dans la clause throws. Si nous utilisons le mot clé throw pour lever une exception vérifiée, nous devons la gérer avec un bloc catch ou la déclarer avec une déclaration throws dans la méthode.
Exemple :comment lancer des exceptions vérifiées
import java.io.*;
public class TestThrowCheckedException {
//function to check if a student qualifies for a specified course or not
public static void method() throws FileNotFoundException {
FileReader file = new FileReader("C:\\Users\\Code\\Desktop\\underscored.txt");
BufferedReader fileInput = new BufferedReader(file);
throw new FileNotFoundException();
}
//main method
public static void main(String args[]){
try
{
method();
}
catch (FileNotFoundException e)
{
e.printStackTrace();
}
System.out.println(" runs after the rest of the code");
}
} En Java, chaque sous-classe Error et RuntimeException est une exception non contrôlée. Tout le reste de la classe Throwable est une exception vérifiée.
Exemple :comment lever des exceptions définies par l'utilisateur
// class representation of user-defined exceptions
class classUserDefinedException extends Exception
{
public classUserDefinedException(String strVal)
{
// Calling constructor of parent Exception
super(strVal);
}
}
// Class using the above UserDefinedException
public class TestThrowUserDefinedException
{
public static void main(String args[])
{
try
{
// throw an object of user defined exception
throw new classUserDefinedException("Elucidating user-defined exceptions");
}
catch ( classUserDefinedException userdefExceptions)
{
System.out.println(" Exceptions caught ");
// Printing UserDefinedException's message object
System.out.println(userdefExceptions .getMessage());
}
}
} Conclusion
Les exceptions en Java nous permettent de produire du code de haute qualité en vérifiant les problèmes au moment de la compilation plutôt qu'au moment de l'exécution. Nous pouvons créer des exceptions personnalisées pour faciliter la récupération et le débogage du code.
