Exception définie par l'utilisateur Java

L'exception Java définie par l'utilisateur est une exception personnalisée créée et lève cette exception à l'aide d'un mot-clé « throw ». Cela se fait en étendant une classe « Exception ». Une exception est un problème qui survient lors de l'exécution du programme. Dans le langage de programmation orienté objet, Java fournit un mécanisme puissant pour gérer de telles exceptions. Java permet de créer sa propre classe d'exception, qui fournit sa propre implémentation de classe d'exception. De telles exceptions sont appelées exceptions définies par l'utilisateur ou exceptions personnalisées. Approfondissons et regardons comment les exceptions définies par l'utilisateur sont créées en Java, sa syntaxe, le cas échéant, et comment elle est implémentée en résolvant quelques exemples.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Commencez votre cours de développement de logiciels libres

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

Syntaxe :

Nous n'avons pas de syntaxe particulière pour les exceptions Java définies par l'utilisateur ; nous verrons comment créer une exception définie par l'utilisateur.

Vous trouverez ci-dessous le code qui aidera à créer une classe d'exception définie par l'utilisateur,

class SampleException{
public static void main(String args[]){
try{
throw new UserException(<value>); // used to create new exception and throw
}
catch(Exception e){
System.out.println(e);
}
}
}
class UserException extends Exception{
// code for exception class
}

Ici, lors de la création d'une classe d'exception, elle doit être étendue depuis Java. lang.Exception.

Une exception est un événement qui entraîne l'arrêt soudain du programme lors de l'exécution au moment de l'exécution.

Exemples

Discutons d'exemples d'exceptions Java définies par l'utilisateur.

Exemple n°1 : Programme simple

class SampleException{
public static void main(String args[]){
try{
throw new UserException(400);
}
catch(UserException e){
System.out.println(e) ;
}
}
}
class UserException extends Exception{
int num1;
UserException(int num2) {
num1=num2;
}
public String toString(){
return ("Status code = "+num1) ;
}
}

Sortie :

Le mot clé « throw » est utilisé pour créer une nouvelle exception et la lancer pour attraper le bloc.

Exemple n°2 : pour une pièce d'identité invalide

class EmployeeException extends Exception
{
public EmployeeException(String s)
{
super(s);
}
}
class SampleEmp
{
void empIDCheck(int EmpID) throws EmployeeException{
if(EmpID<=0 || EmpID>999){
throw new EmployeeException("Invalid Employee ID");
}
}
public static void main(String args[])
{
SampleEmp emp = new SampleEmp();
try
{
emp.empIDCheck(0);
}
catch (EmployeeException e)
{
System.out.println("Exception caught");
System.out.println(e.getMessage());
}
}
}

Sortie :

Si nous n'utilisons pas la classe throw ici, cela donnerait une erreur de compilation telle que « Exception non gérée dans la méthode ».

Exemple n°3 : Pour une valeur inférieure à la valeur définie

class SampleException extends Exception
{
private int e;
SampleException(int num1)
{
e = num1;
}
public String toString()
{
return "(" + e +") is less than Ten";
}
}
class Demo1
{
static void sum(int num,int num1) throws SampleException
{
if(num1<10)
{
throw new SampleException(num1);
}
else
{
System.out.println(num+num1);
}
}
public static void main(String[] args)
{
try
{
sum(-5, 4);
}
catch(SampleException e1)
{
System.out.println(e1);
}
}
}

Sortie :

Exemple n°4 : Pour vérifier la validité de l'identité

class IDNotValid extends Exception
{
public IDNotValid(String s) {
super(s);
}
}
class Demo
{
static void find(int array[], int id) throws IDNotValid
{
boolean stdFlag = false;
for (int i = 0; i < array.length; i++) {
if(id == array[i])
stdFlag = true;
}
if(!stdFlag)
{
throw new IDNotValid("ID is not Valid!");
}
else
{
System.out.println("ID is Valid!");
}
}
public static void main(String[] args)
{
try
{
find(new int[]{101, 102, 103, 104, 105, 106, }, 108);
}
catch(IDNotValid e)
{
System.out.println(e);
}
}
}

Sortie :

Ici, nous générons notre propre implémentation d'exception.

Il y a des avantages à utiliser ces exceptions définies par l'utilisateur ; cela permet aux utilisateurs de lever une exception que l'utilisateur souhaite vouloir dire. Les utilisateurs peuvent également réutiliser n'importe quelle application existante ; tout morceau de code qui détecte une exception traite d'une possibilité d'exception réelle n'a pas été lancé par le code mais par un autre code tiers.
Les utilisateurs peuvent séparer le code de gestion des erreurs du code normal, en regroupant et en différenciant les types d'erreurs.
Il existe également quelques règles pour créer des classes d'exception.

• Constructeur : Ceci n'est pas obligatoire lors de la création d'un constructeur dans la classe d'exception personnalisée. Fournir des constructeurs paramétrés dans la classe d'exception personnalisée est une bonne pratique.
• Convention de dénomination : Toutes les classes d'exception sont fournies par la fin du JDK ; par conséquent, une exception personnalisée doit suivre une convention de dénomination.
• Extend la classe Exception : Si l'utilisateur crée une classe d'exception personnalisée, il doit alors étendre la classe Exception.

Avec cela, nous conclurons le sujet « Classe d'exceptions utilisateur Java ». Presque toutes les exceptions générales en Java sont fournies et se produisent dans la programmation Java. Nous avons assisté à la création de classes d'exceptions définies par l'utilisateur et avons vu quelques exemples d'exceptions définies par l'utilisateur. L'utilisateur n'a pas besoin d'implémenter quoi que ce soit à l'intérieur de la classe ; aucune méthode n'est requise et remplacez également la fonction toString() pour afficher des messages personnalisés.

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!