Java - Exceptions
Une exception (ou événement exceptionnel) est un problème qui survient lors de l'exécution d'un programme. Lorsqu'une exception se produit, le déroulement normal du programme est interrompu et le programme/l'application se termine anormalement, ce qui n'est pas recommandé, par conséquent, ces exceptions doivent être gérées.
Une exception peut se produire pour de nombreuses raisons différentes. Voici quelques scénarios où une exception se produit.
-
Un utilisateur a entré une donnée invalide.
-
Un fichier qui doit être ouvert est introuvable.
-
Une connexion réseau a été perdue au milieu des communications ou la JVM a manqué de mémoire.
Certaines de ces exceptions sont causées par une erreur de l'utilisateur, d'autres par une erreur du programmeur et d'autres par des ressources physiques qui ont échoué d'une manière ou d'une autre.
Sur cette base, nous avons trois catégories d'exceptions. Vous devez les comprendre pour savoir comment fonctionne la gestion des exceptions en Java.
-
Exceptions vérifiées − Une exception vérifiée est une exception vérifiée (notifiée) par le compilateur au moment de la compilation, elles sont également appelées exceptions au moment de la compilation. Ces exceptions ne peuvent pas simplement être ignorées, le programmeur doit prendre soin de (gérer) ces exceptions.
Par exemple, si vous utilisez FileReader classe dans votre programme pour lire les données d'un fichier, si le fichier spécifié dans son constructeur n'existe pas, alors une FileNotFoundException se produit et le compilateur demande au programmeur de gérer l'exception.
Exemple
Démo en direct
import java.io.File;
import java.io.FileReader;
public class FilenotFound_Demo {
public static void main(String args[]) {
File file = new File("E://file.txt");
FileReader fr = new FileReader(file);
}
}
Si vous essayez de compiler le programme ci-dessus, vous obtiendrez les exceptions suivantes.
Sortie
C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.java:8: error: unreported exception FileNotFoundException; must be caught or declared to be thrown
FileReader fr = new FileReader(file);
^
1 error
Remarque − Puisque les méthodes read() et fermer() de la classe FileReader lève IOException, vous pouvez observer que le compilateur notifie de gérer IOException, avec FileNotFoundException.
-
Exceptions non contrôlées − Une exception non vérifiée est une exception qui se produit au moment de l'exécution. Celles-ci sont également appelées Exceptions d'exécution . Ceux-ci incluent des bogues de programmation, tels que des erreurs de logique ou une mauvaise utilisation d'une API. Les exceptions d'exécution sont ignorées au moment de la compilation.
Par exemple, si vous avez déclaré un tableau de taille 5 dans votre programme et que vous essayez d'appeler le 6 ème élément du tableau puis une ArrayIndexOutOfBoundsExceptionexception se produit.
Exemple
Démo en direct
public class Unchecked_Demo {
public static void main(String args[]) {
int num[] = {1, 2, 3, 4};
System.out.println(num[5]);
}
}
Si vous compilez et exécutez le programme ci-dessus, vous obtiendrez l'exception suivante.
Sortie
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5 at Exceptions.Unchecked_Demo.main(Unchecked_Demo.java:8)
-
Erreurs − Ce ne sont pas du tout des exceptions, mais des problèmes qui surgissent au-delà du contrôle de l'utilisateur ou du programmeur. Les erreurs sont généralement ignorées dans votre code car vous pouvez rarement faire quoi que ce soit à propos d'une erreur. Par exemple, si un débordement de pile se produit, une erreur se produira. Ils sont également ignorés au moment de la compilation.
Hiérarchie des exceptions
Toutes les classes d'exception sont des sous-types de la classe java.lang.Exception. La classe exception est une sous-classe de la classe Throwable. Outre la classe d'exception, il existe une autre sous-classe appelée Error qui est dérivée de la classe Throwable.
Les erreurs sont des conditions anormales qui se produisent en cas de pannes graves, elles ne sont pas gérées par les programmes Java. Des erreurs sont générées pour indiquer les erreurs générées par l'environnement d'exécution. Exemple :JVM n'a plus de mémoire. Normalement, les programmes ne peuvent pas récupérer des erreurs.
La classe Exception a deux sous-classes principales :la classe IOException et la classe RuntimeException.
Vous trouverez ci-dessous une liste des exceptions intégrées Java cochées et non cochées les plus courantes.
Méthodes d'exception
Voici la liste des méthodes importantes disponibles dans la classe Throwable.
| Sr.No. | Méthode et description |
|---|---|
| 1 | |
| 2 | |
| 3 | |
| 4 | |
| 5 | |
| 6 |
Récupérer les exceptions
Une méthode intercepte une exception en utilisant une combinaison de try et attraper mots clés. Un bloc try/catch est placé autour du code susceptible de générer une exception. Le code dans un bloc try/catch est appelé code protégé, et la syntaxe pour utiliser try/catch ressemble à ce qui suit −
Syntaxe
try {
// Protected code
} catch (ExceptionName e1) {
// Catch block
}
Le code sujet aux exceptions est placé dans le bloc try. Lorsqu'une exception se produit, cette exception est gérée par le bloc catch qui lui est associé. Chaque bloc try doit être immédiatement suivi d'un bloc catch ou d'un bloc finally.
Une instruction catch implique de déclarer le type d'exception que vous essayez d'attraper. Si une exception se produit dans le code protégé, le ou les blocs catch qui suivent l'essai sont vérifiés. Si le type d'exception qui s'est produit est répertorié dans un bloc catch, l'exception est transmise au bloc catch comme un argument est transmis à un paramètre de méthode.
Exemple
Voici un tableau déclaré avec 2 éléments. Ensuite, le code essaie d'accéder au 3 rd élément du tableau qui lève une exception.
Démo en direct
// File Name : ExcepTest.java
import java.io.*;
public class ExcepTest {
public static void main(String args[]) {
try {
int a[] = new int[2];
System.out.println("Access element three :" + a[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
}
Cela produira le résultat suivant −
Sortie
Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 Out of the block
Plusieurs blocs de capture
Un bloc try peut être suivi de plusieurs blocs catch. La syntaxe pour plusieurs blocs catch ressemble à ce qui suit −
Syntaxe
try {
// Protected code
} catch (ExceptionType1 e1) {
// Catch block
} catch (ExceptionType2 e2) {
// Catch block
} catch (ExceptionType3 e3) {
// Catch block
}
Les instructions précédentes illustrent trois blocs catch, mais vous pouvez en avoir n'importe quel nombre après un seul essai. Si une exception se produit dans le code protégé, l'exception est renvoyée au premier bloc catch de la liste. Si le type de données de l'exception levée correspond à ExceptionType1, elle y est interceptée. Si ce n'est pas le cas, l'exception est transmise à la deuxième instruction catch. Cela continue jusqu'à ce que l'exception soit interceptée ou passe par toutes les interceptions, auquel cas la méthode actuelle arrête l'exécution et l'exception est renvoyée à la méthode précédente sur la pile des appels.
Exemple
Voici un segment de code montrant comment utiliser plusieurs instructions try/catch.
try {
file = new FileInputStream(fileName);
x = (byte) file.read();
} catch (IOException i) {
i.printStackTrace();
return -1;
} catch (FileNotFoundException f) // Not valid! {
f.printStackTrace();
return -1;
}
Récupérer plusieurs types d'exceptions
Depuis Java 7, vous pouvez gérer plusieurs exceptions à l'aide d'un seul bloc catch, cette fonctionnalité simplifie le code. Voici comment procéder −
catch (IOException|FileNotFoundException ex) {
logger.log(ex);
throw ex;
Les lancers/mots clés de lancer
Si une méthode ne gère pas une exception vérifiée, la méthode doit la déclarer en utilisant les throws mot-clé. Le mot clé throws apparaît à la fin de la signature d'une méthode.
Vous pouvez lancer une exception, qu'elle soit nouvellement instanciée ou une exception que vous venez d'attraper, en utilisant le throw mot-clé.
Essayez de comprendre la différence entre lancers et jeter les mots-clés, lancements est utilisé pour différer le traitement d'une exception cochée et lancer est utilisé pour invoquer explicitement une exception.
La méthode suivante déclare qu'elle lève une RemoteException −
Exemple
import java.io.*;
public class className {
public void deposit(double amount) throws RemoteException {
// Method implementation
throw new RemoteException();
}
// Remainder of class definition
}
Une méthode peut déclarer qu'elle lève plus d'une exception, auquel cas les exceptions sont déclarées dans une liste séparée par des virgules. Par exemple, la méthode suivante déclare qu'elle lève une RemoteException et une InsufficientFundsException −
Exemple
import java.io.*;
public class className {
public void withdraw(double amount) throws RemoteException,
InsufficientFundsException {
// Method implementation
}
// Remainder of class definition
}
Le bloc Enfin
Le bloc finally suit un bloc try ou un bloc catch. Un bloc de code finally s'exécute toujours, quelle que soit l'occurrence d'une exception.
L'utilisation d'un bloc finally vous permet d'exécuter toutes les instructions de type nettoyage que vous souhaitez exécuter, peu importe ce qui se passe dans le code protégé.
Un bloc finally apparaît à la fin des blocs catch et a la syntaxe suivante −
Syntaxe
try {
// Protected code
} catch (ExceptionType1 e1) {
// Catch block
} catch (ExceptionType2 e2) {
// Catch block
} catch (ExceptionType3 e3) {
// Catch block
}finally {
// The finally block always executes.
}
Exemple
Démo en direct
public class ExcepTest {
public static void main(String args[]) {
int a[] = new int[2];
try {
System.out.println("Access element three :" + a[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exception thrown :" + e);
}finally {
a[0] = 6;
System.out.println("First element value: " + a[0]);
System.out.println("The finally statement is executed");
}
}
}
Cela produira le résultat suivant −
Sortie
Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 First element value: 6 The finally statement is executed
Notez ce qui suit −
-
Une clause catch ne peut pas exister sans une instruction try.
-
Il n'est pas obligatoire d'avoir des clauses finally chaque fois qu'un bloc try/catch est présent.
-
Le bloc try ne peut pas être présent sans clause catch ni clause finally.
-
Aucun code ne peut être présent entre les blocs try, catch, finally.
L'essai avec des ressources
Généralement, lorsque nous utilisons des ressources telles que des flux, des connexions, etc., nous devons les fermer explicitement à l'aide de finally block. Dans le programme suivant, nous lisons les données d'un fichier à l'aide de FileReader et nous le fermons en utilisant le bloc finally.
Exemple
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class ReadData_Demo {
public static void main(String args[]) {
FileReader fr = null;
try {
File file = new File("file.txt");
fr = new FileReader(file); char [] a = new char[50];
fr.read(a); // reads the content to the array
for(char c : a)
System.out.print(c); // prints the characters one by one
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fr.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
}
essayer avec des ressources , également appelée gestion automatique des ressources , est un nouveau mécanisme de gestion des exceptions introduit dans Java 7, qui ferme automatiquement les ressources utilisées dans le bloc try catch.
Pour utiliser cette instruction, il vous suffit de déclarer les ressources requises entre parenthèses, et la ressource créée sera automatiquement fermée à la fin du bloc. Voici la syntaxe de l'instruction try-with-resources.
Syntaxe
try(FileReader fr = new FileReader("file path")) {
// use the resource
} catch () {
// body of catch
}
}
Voici le programme qui lit les données dans un fichier à l'aide de l'instruction try-with-resources.
Exemple
import java.io.FileReader;
import java.io.IOException;
public class Try_withDemo {
public static void main(String args[]) {
try(FileReader fr = new FileReader("E://file.txt")) {
char [] a = new char[50];
fr.read(a); // reads the contentto the array
for(char c : a)
System.out.print(c); // prints the characters one by one
} catch (IOException e) {
e.printStackTrace();
}
}
}
Les points suivants doivent être gardés à l'esprit lors de l'utilisation de l'instruction try-with-resources.
-
Pour utiliser une classe avec l'instruction try-with-resources, elle doit implémenter AutoCloseable interface et le close() méthode est invoquée automatiquement lors de l'exécution.
-
Vous pouvez déclarer plusieurs classes dans l'instruction try-with-resources.
-
Lorsque vous déclarez plusieurs classes dans le bloc try de l'instruction try-with-resources, ces classes sont fermées dans l'ordre inverse.
-
À l'exception de la déclaration des ressources entre parenthèses, tout est identique à un bloc try/catch normal d'un bloc try.
-
La ressource déclarée dans try est instanciée juste avant le début du bloc try.
-
La ressource déclarée au bloc try est implicitement déclarée final.
Exceptions définies par l'utilisateur
Vous pouvez créer vos propres exceptions en Java. Gardez les points suivants à l'esprit lors de l'écriture de vos propres classes d'exception −
-
Toutes les exceptions doivent être un enfant de Throwable.
-
Si vous souhaitez écrire une exception vérifiée qui est automatiquement appliquée par la règle Handle ou Declare, vous devez étendre la classe Exception.
-
Si vous souhaitez écrire une exception d'exécution, vous devez étendre la classe RuntimeException.
Nous pouvons définir notre propre classe Exception comme ci-dessous −
class MyException extends Exception {
}
Il vous suffit d'étendre l'exception prédéfinie classe pour créer votre propre exception. Celles-ci sont considérées comme des exceptions vérifiées. L'exception InsufficientFundsException suivante La classe est une exception définie par l'utilisateur qui étend la classe Exception, ce qui en fait une exception vérifiée. Une classe d'exception est comme n'importe quelle autre classe, contenant des champs et des méthodes utiles.
Exemple
// File Name InsufficientFundsException.java
import java.io.*;
public class InsufficientFundsException extends Exception {
private double amount;
public InsufficientFundsException(double amount) {
this.amount = amount;
}
public double getAmount() {
return amount;
}
}
Pour illustrer l'utilisation de notre exception définie par l'utilisateur, la classe CheckingAccount suivante contient une méthode retrait() qui lève une InsufficientFundsException.
// File Name CheckingAccount.java
import java.io.*;
public class CheckingAccount {
private double balance;
private int number;
public CheckingAccount(int number) {
this.number = number;
}
public void deposit(double amount) {
balance += amount;
}
public void withdraw(double amount) throws InsufficientFundsException {
if(amount <= balance) {
balance -= amount;
}else {
double needs = amount - balance;
throw new InsufficientFundsException(needs);
}
}
public double getBalance() {
return balance;
}
public int getNumber() {
return number;
}
}
Le programme BankDemo suivant illustre l'appel des méthodes de dépôt () et de retrait () de CheckingAccount.
// File Name BankDemo.java
public class BankDemo {
public static void main(String [] args) {
CheckingAccount c = new CheckingAccount(101);
System.out.println("Depositing $500...");
c.deposit(500.00);
try {
System.out.println("\nWithdrawing $100...");
c.withdraw(100.00);
System.out.println("\nWithdrawing $600...");
c.withdraw(600.00);
} catch (InsufficientFundsException e) {
System.out.println("Sorry, but you are short $" + e.getAmount());
e.printStackTrace();
}
}
}
Compilez les trois fichiers ci-dessus et exécutez BankDemo. Cela produira le résultat suivant −
Sortie
Depositing $500...
Withdrawing $100...
Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
at CheckingAccount.withdraw(CheckingAccount.java:25)
at BankDemo.main(BankDemo.java:13)
Exceptions courantes
En Java, il est possible de définir deux catégories d'Exceptions et d'Erreurs.
-
Exceptions JVM − Ce sont des exceptions/erreurs qui sont exclusivement ou logiquement levées par la JVM. Exemples :NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException.
-
Exceptions programmatiques − Ces exceptions sont lancées explicitement par l'application ou les programmeurs de l'API. Exemples :IllegalArgumentException, IllegalStateException.
Java