La gestion des exceptions en Java est l'un des concepts les plus importants que vous apprendrez en tant que développeur Java ! Ce didacticiel vous aide à comprendre et à implémenter correctement la gestion des exceptions.
Chaque programme informatique a un flux spécifique dans lequel il s'exécute. Si quelque chose inattendu se produit, cela entraîne une perturbation du déroulement normal du programme.
Par exemple, la division de toute valeur numérique par zéro ou l'accès à un index qui n'existe pas dans un tableau. Ce phénomène est qualifié de exception en programmation.
En termes simples, une exception est quelque chose auquel vous ne vous attendiez pas, mais cela peut arriver et vous devez ensuite le gérer.
Pourquoi une exception se produit-elle ?
Le point clé ici est possibilité. Il y a plusieurs choses qui pourraient mal tourner. L'état du réseau, l'interaction de l'utilisateur, les entrées invalides, etc., sont quelques-unes des choses qui pourraient conduire à une exception. Ce qui est important, c'est la façon dont vous gérez les exceptions qui, selon vous, se produiront d'une manière ou d'une autre.
Exception Handling by JVM
Lorsqu'une exception se produit dans un programme Java, un objet est créé qui décrit l'exception, y compris son type et l'état du programme lorsqu'elle s'est produite. Cet objet est ensuite passé au Machine virtuelle Java (JVM). La JVM essaie de trouver une méthode ou une fonction pour gérer l'exception. Il passe par une liste de méthodes qui peuvent potentiellement gérer l'exception.
Une fois qu'il a trouvé la méthode appropriée pour gérer l'exception, il transmet l'exception à la méthode, mais s'il ne trouve pas de méthode appropriée, il termine le programme en appelant la méthode de gestion des exceptions par défaut.
Types of Exceptions in Java
Les exceptions en Java sont de deux types :
à carreaux: Ces types d'exceptions sont interceptés par le compilateur au moment de la compilation. Certaines des exceptions vérifiées dans Java incluent IOException et SQLException.
Incontrôlé: Le compilateur n'a pas connaissance de ces exceptions au moment de la compilation car elles deviennent évidentes au moment de l'exécution. Ils sont vérifiés lorsque le code est exécuté. Les exceptions non vérifiées incluent ArrayIndexOutOfBoundsException et IllegalStateException.
Ways to Handle an Exception
Voici quelques façons de gérer ou de lever une exception :
- essayez… attrapez le bloc
- lancer/lancer le mot-clé
# 1. essayez… attrapez le bloc
Le bloc try-catch est utilisé pour exécuter un morceau de code dans lequel il est possible qu'une exception se produise. Les Essai et capture les blocs sont deux blocs de code distincts - capture bloc s'exécute lorsque le Essai bloc ne s'exécute pas normalement.
try {
// normal code
} catch(Exception e) {
// code which handles an exception
}Il y a aussi un enfin bloc que vous pouvez utiliser pour exécuter du code, qu'une exception se produise ou non. Le code de ce bloc s'exécutera dans tous les cas.
try {
// normal code
} catch(Exception e) {
// code which handles an exception
} finally {
// some code
}# 2. lancer et lancer le mot-clé
Les renversement mot clé est utilisé pour créer explicitement une seule exception. Vous pouvez utiliser renversement si vous savez qu'une exception peut certainement se produire pour une condition particulière.
public static void occur() {
// condition
throw new ArithmeticException();
}
public static void main(String[] args) {
try {
occur();
} catch(Exception e) {
// handle
}
}Vous pouvez utiliser le jette mot clé pour indiquer plusieurs exceptions dont vous savez qu'elles se produiront dans une méthode donnée.
public static void occur() throws Exception1, Exception2, Exception3 {
// conditions which throw different exceptions
}
public static void main(String[] args) {
try {
occur();
} catch(Exception1 e) {
//...
} catch(Exception2 e) {
//...
} catch(Exception3 e) {
//...
}
}Some Common Exceptions in Java
# 1. IOException
Une IOException peut se produire en Java s'il y a un problème avec le processus d'entrée/sortie. Cela se produit généralement lorsque vous essayez d'accéder à un fichier et à son contenu, mais que le fichier n'existe pas ou qu'il y a un problème de lecture du contenu qu'il contient.
import java.io.FileNotFoundException;
import java.io.FileReader;
public class Main {
public static void main(String[] args) {
try {
FileReader file = new FileReader("hello.txt");
} catch (FileNotFoundException e) {
System.out.println(e.getMessage());
}
}
}# 2. ArrayIndexOutOfBoundsExceptionArrayIndexOutOfBoundsException
Un tableau est une structure de données qui stocke des valeurs du même type de données et chaque valeur a un index qui commence à partir de 0 et monte jusqu'à (n-1) où n est le nombre total de valeurs présentes dans le tableau. Vous pouvez accéder à un élément en spécifiant l'index avec le nom de la variable référençant le tableau :
array[index]Maintenant, si vous essayez d'accéder à un élément avec un index inférieur à 0 ou supérieur à (n-1), une exception se produira car il n'y a aucun élément à cet index particulier. Ce type d'exception est appelé ArrayIndexOutOfBoundsException et se produit au moment de l'exécution.
public class Main {
public static void main(String[] args) {
try {
int[] arr = {34, 1, 78, 3, 5};
int element = arr[7];
} catch (Exception e) {
System.out.println(e);
}
}
}# 3. ClassCastException
Ce type d'exception se produit lorsque vous essayez de transtyper l'objet d'une classe parent avec le type de l'une de ses sous-classes. Vous pouvez également obtenir cette exception si vous essayez de transtyper un objet avec une classe avec laquelle il n'est pas compatible.
class A {
public void display() {
System.out.println("This is class A");
}
}
class B extends A {
public void display() {
System.out.println("This is class B which is a subclass of A");
}
}
class C extends B {
public void display() {
System.out.println("This is class C which is a subclass of B");
}
}
public class Main {
public static void main(String[] args) {
try {
A objA = new A();
B objB = (B) new A();
} catch (Exception e) {
System.out.println(e);
}
}
}Le code ci-dessus lèvera une ClassCastException car nous essayons de transtyper un objet de la classe parent avec le type de sa sous-classe.
# 4. Exception d'argument illégal
Lorsqu'une méthode ou une fonction reçoit un argument qui n'est pas valide, elle peut lever une IllegalArgumentException. Par exemple, supposons que vous créez une méthode pour calculer le périmètre d'un carré.
En demandant la longueur d'un côté du carré de l'utilisateur, si vous obtenez une valeur négative, vous pouvez lever cette exception car le côté d'un carré ne peut pas être négatif.
public class Main {
public static int perimeter(int length) {
if(length < 0) {
throw new IllegalArgumentException("No negative values are allowed!");
}
return 4 * length;
}
public static void main(String[] args) {
try {
System.out.println(perimeter(-5));
} catch (Exception e) {
System.out.println(e);
}
}
}# 5. IllegalStateException
Lorsque vous appelez une méthode ou une fonction à un moment où elle ne devrait pas être appelée, vous obtenez une IllegalStateException. Par exemple, si vous appelez la méthode start sur un thread qui a déjà été démarré, Java lèvera cette exception lors de l'exécution.
class AThread extends Thread {
public void run() {
System.out.println("This is a thread!");
}
}
public class Main {
public static void main(String[] args) {
try {
AThread t = new AThread();
t.start();
t.start();
} catch (Exception e) {
System.out.println(e);
}
}
}# 6. NullPointerException
Cela se produit lorsque vous essayez d'accéder aux propriétés d'un objet nul ou d'une variable pointant vers une valeur nulle. Null est une valeur spéciale en Java qui indique qu'aucune valeur n'est affectée à une variable de référence.
public class Main {
public static void main(String[] args) {
try {
String num = null;
System.out.println(num.length());
} catch (Exception e) {
System.out.println(e);
}
}
}# 7. NumberFormatException
Cela se produit lorsque vous essayez de convertir une chaîne mal formatée en un nombre. Par exemple, si vous essayez de convertir "null" ou "vingt" en un nombre, alors java lèvera cette exception.
public class Main {
public static void main(String[] args) {
try {
int num = Integer.parseInt("12,389");
System.out.println(num);
} catch (Exception e) {
System.out.println(e);
}
}
}Conclusion
La gestion des exceptions est importante car elles peuvent créer des interruptions inutiles dans le déroulement du programme. Notez que les exceptions sont différentes des erreurs car les exceptions doivent être gérées, alors que les erreurs ne peuvent pas être gérées. Au lieu de cela, ils devraient être résolus ou corrigés. Vous pouvez en apprendre plus sur Java en parcourant ces cours Java en ligne.
