Gestion des exceptions en Java [avec exemples]

Les exceptions sont l'événement indésirable et inattendu d'un programme qui n'est jamais souhaité par un programmeur mais qui doit y faire face tant de fois. Le bon côté est qu'il est possible avec le langage orienté objet Java d'atténuer ces événements indésirables grâce à un concept appelé "Exception Handling in Java ". Il ne répare pas l'exception mais fournit une autre façon de la traiter.

Il peut y avoir de nombreuses raisons pour qu'une exception se produise, y compris la saisie de données incorrectes, une panne matérielle, une panne de connexion, une panne de serveur, etc. Ainsi, la gestion des exceptions est et sera toujours importante dans le cadre de l'apprentissage de Java car elle aide à assurer le déroulement d'un programme au moment où un événement inattendu se produit. Ignorer les exceptions peut entraîner le blocage de l'ensemble du logiciel et entraîner la perte de données.

Maintenant que nous avons une idée des exceptions et de la gestion des exceptions, plongeons-y en détail et comprenons également comment Java aide à gérer les exceptions.

Lire : Questions d'entretien sur la gestion des exceptions

Qu'est-ce que la gestion des exceptions ?

Un développeur peut prédire les exceptions qu'un morceau de code peut lever pendant l'exécution. L'une des choses les plus importantes sur lesquelles de nombreux apprenants deviennent ambigus est que toutes les exceptions se produisent pendant l'exécution et non au moment de la compilation. Java peut gérer les exceptions uniquement pendant l'exécution. Certains mots-clés sont utilisés dans un programme Java pour créer un bloc de gestionnaire d'exceptions.

java.lang.Exception est la classe parent de toutes les classes d'exception. La classe Exception est une sous-classe de la classe intégrée Throwable qui est une sous-classe de la classe Object . Outre Exception, Throwable a également une autre classe, à savoir Error, qui est une condition anormale lors de l'exécution du programme qui ne peut pas être gérée par les programmes Java, qui constituent la principale différence entre Error et Exceptions.

Comme le montre la figure ci-dessus, il existe principalement deux catégories d'exceptions en Java. Dans la section suivante, nous verrons en détail les types d'exceptions en Java.

Exception Java

Les causes profondes des exceptions sont celles causées par le programmeur ou par des ressources physiques qui ont échoué pour certaines raisons. Sur cette base, il existe principalement deux catégories d'exceptions en Java, dont les détails sont suivis ci-dessous :

1. Exception vérifiée
2. Exception non vérifiée

1. Exception vérifiée

Les exceptions vérifiées sont appelées "exceptions au moment de la compilation" car elles sont vérifiées lors de la compilation par le compilateur pour surveiller si l'exception est gérée par le programmeur. Le système affiche alors une erreur de compilation.

Quelques exemples de ces exceptions sont IOException , Lire : Idées de projets Java pour les débutants

2. Exception non cochée

Les exceptions non vérifiées sont appelées "exceptions d'exécution" car elles se produisent pendant l'exécution du programme. Les exceptions non vérifiées sont normalement ignorées lors de la compilation et ne sont pas vérifiées.

Des exemples de ces exceptions peuvent être des bogues dans un programme tels que des erreurs logiques ou l'utilisation d'API incorrectes qui ne sont pas sous le contrôle d'un programmeur et nécessitent la correction d'un administrateur système.

Exception vérifiée contre non vérifiée

Comprendre les exceptions est la première étape avant de les gérer.

Comment Java aide-t-il à gérer les exceptions ?

Maintenant que nous savons qu'il existe deux types d'exceptions dans Java, à savoir, cochées et non cochées. Si une méthode lève une exception vérifiée, elle doit être gérée avec un bloc try-catch ou le mot- clé « throws » doit être déclaré pour éviter une erreur de compilation dans un programme.

Exemple d'exception vérifiée :

Il s'agit d'un programme de lecture d'un fichier nommé 'Java'. Il y a trois endroits où une exception vérifiée est levée :

1. FileInputStream : utilisé pour spécifier le chemin et le nom du fichier, lancer FileNotFoundException .
2. La méthode read() : La lecture du contenu du fichier lance IOException ;

iii. La méthode close() : la fermeture du flux d'entrée du fichier lève IOException .

importer java.io.* ;

classe Exemple {

public static void main( String args[])

{

FileInputStream fis = null ;

/*Le constructeur FileInputStream(File filename)

* lance une exception vérifiée FileNotFoundException */

fis = nouveau FileInputStream ( "B:/java.txt" );

entier k ;

/* La méthode read() de la classe FileInputStream lance

* une exception vérifiée : IOException

*/

tandis que (( k = fis.read() ) != – 1 )

{

Système . dehors . print (( char )k);

}

/*La méthode close() ferme le flux d'entrée du fichier

* lance IOException */

fis.close();

}

}

Sortie du programme ci-dessus :

Exception trouvée dans le thread "main" java.lang. Erreur : Problèmes de compilation non résolus :

Exception non gérée FileNotFoundException trouvée

Exception non gérée IOException trouvée

Exception non gérée IOException trouvée

La raison de cette erreur de compilation : Non déclaration ou gestion des exceptions.

Doit lire : Projets Java GitHub

Méthodes de gestion des exceptions

Il existe deux manières de gérer les exceptions décrites ci-dessous :

Méthode 1 : déclaration du mot-clé d'exception 'throws'

Dans le programme ci-dessus, les trois exceptions vérifiées se trouvent dans la méthode main(). Ainsi, une façon d'éviter l'erreur de compilation est de déclarer l'exception dans la méthode en utilisant le mot clé 'throws'. Comme IOException est une classe parente de FileNotFoundException, elle couvrira également cela.

Programme mis à jour à l'aide du mot-clé throws :

importer java.io.* ;

classe Exemple {

public static void main( String args[]) lance IOException

{

FileInputStream fis = null ;

fis = nouveau FileInputStream ( "B:/java.txt" );

entier k ;

tandis que (( k = fis.read() ) != – 1 )

{

Système . dehors . print (( char )k);

}

fis.close();

}

}

Sortir:

Affichez le contenu du fichier à l'écran.

Méthode 2 : gérer les exceptions à l'aide de blocs try-catch.

Il s'agit d'une approche plus avancée de celle ci-dessus et de l'une des meilleures pratiques de gestion des exceptions . Le code de programme modifié, y compris les blocs try-catch, est le suivant :

importer java.io.* ;

classe Exemple {

public static void main( String args[])

{

FileInputStream fis = null ;

essayer {

fis = nouveau FileInputStream ( "B:/java.txt" );

} catch ( FileNotFoundException fnfe){

Système . out .println( "Le fichier n'est pas " +

"présent sur le chemin spécifié" );

}

entier k ;

essayer {

tandis que (( k = fis.read() ) != – 1 )

{

Système . dehors . print (( char )k);

}

fis.close();

} catch ( IOException ioe){

Système . out .println( "Erreur d'E/S " +ioe);

}

}

}

Sortir:

Ce code affichera éventuellement le contenu du fichier.

Exemple d'exception non contrôlée

Les exceptions non vérifiées ne sont pas vérifiées au moment de la compilation. Le programme ne donnera pas d'erreur de compilation s'il n'est pas déclaré ou géré et fonctionnera correctement. Le travail du développeur consiste à prévoir à l'avance les conditions susceptibles de provoquer de telles exceptions et à les gérer. Toutes les exceptions non vérifiées sont des sous-classes de la classe RuntimeException .

classe Exemple {

public static void main( String args[])

{

entier num1 = 10 ;

entier num2 = 0 ;

/*Diviser n'importe quel nombre par 0

* Lancera ArithmeticException

*/

int res=num1/num2 ;

Système . out .println(res);

}

}

Le code se compilera avec succès avec ce code mais pendant l'exécution, il lancera ArithmeticException car les exceptions non vérifiées ne sont pas vérifiées au moment de la compilation. Prenons un autre exemple.

classe Exemple {

public static void main( String args[])

{

int arr[] ={ 1 , 2 , 3 , 4 , 5 } ;

/* Le tableau a 5 éléments mais nous voulons

* afficher la valeur du 8e élément. ça va jeter

* ArrayIndexOutOfBoundsException

*/

Système . out .println(arr[ 7 ]);

}

}

Ce code sera également compilé avec succès car ArrayIndexOutOfBoundsException est une exception non contrôlée.

Ici, pour gérer les exceptions non vérifiées, il devrait y avoir un message d'exception affiché à l'utilisateur qu'il souhaite afficher, mais il n'existe pas dans le tableau.

Gestion de l'exception de code ci-dessus avec le bloc try-catch

classe Exemple {

public static void main( String args[]) {

essayer {

int arr[] ={ 1 , 2 , 3 , 4 , 5 } ;

Système . out .println(arr[ 7 ]);

}

catch ( ArrayIndexOutOfBoundsException e){

Système . out .println( "L'index spécifié n'existe pas " +

"dans le tableau". );

}

}

}

Sortir:

L' index spécifié n'existe pas dans le tableau.

Remarque : Il peut y avoir plusieurs blocs catch dans un bloc try pour gérer différentes exceptions.

Méthode 3 : Utilisation du mot clé 'finally'

Il arrive parfois qu'un code doive être exécuté même si une exception se produit. C'est là que le mot-clé final est utilisé. Voici un code typique avec le mot clé 'finally'.

public int getPlayerScore(String playerFile)

lance FileNotFoundException {

Contenu de l'analyseur = null ;

essayer {

contents = new Scanner( new File(playerFile));

return Integer.parseInt(contents.nextLine());

} enfin {

si (contenu != null ) {

contenu.close();

}

}

}

Ici, le dernier bloc indique le code que nous voulons que Java exécute en essayant de lire le fichier.

Même si une FileNotFoundException est levée, Java appellera le contenu de finally .

Nous pouvons gérer l'exception en modifiant le code comme ci-dessous :

public int PlayerScore(String playerRuns) {

Contenu du scanneur ;

essayer {

contents = new Scanner(new File(playerRuns));

return Integer.parseInt(contents.nextLine());

} catch (FileNotFoundException noFile ) {

logger.warn("Fichier introuvable.");

renvoie 0 ;

} finalement {

essayer {

si (contenu != null) {

contenu.close();

}

} capture (IOException ioexc) {

logger.error("Le lecteur n'a pas pu être fermé.", ioexc);

}

}

}

Conclusion

Avec cet article, nous avons essayé de passer en revue les bases des erreurs et des exceptions et de la gestion des exceptions en Java . Nous espérons que ce guide vous donnera une bonne idée de cette fonctionnalité unique offerte par Java et que vous pourrez désormais gérer les exceptions et mieux vous en remettre. Conclusion

Java fournit des moyens de gérer les exceptions, des plus spécifiques aux plus génériques. Les exceptions qui ne peuvent pas être prédites facilement à l'avance sont appelées exceptions non gérées. La capture de toutes les exceptions offre une visibilité à l'équipe de développement sur la qualité du code et les causes profondes des erreurs qui peuvent être corrigées rapidement.

Si vous souhaitez en savoir plus sur Java et le développement full stack, consultez le diplôme PG upGrad & IIIT-B en développement logiciel full stack. Il est soigneusement organisé pour les professionnels et assure un soutien de carrière à 360 degrés et comprend des projets en direct sur lesquels travailler. À la fin du cours, vous serez en mesure de concevoir et de créer des applications telles que Swiggy, IMDB, etc.

Cela ne semble-t-il pas excitant ! -

Devenir Développeur Full Stack

MISE À NIVEAU ET DIPLÔME PG DE L'IIIT-BANGALORE EN DÉVELOPPEMENT LOGICIEL

Apprendre encore plus