En Java, exception est un événement qui se produit lors de l'exécution d'un programme et perturbe le flux normal des instructions du programme. Les bogues ou erreurs que nous ne voulons pas et qui restreignent l'exécution normale du code de notre programme sont appelés des exceptions . Dans cette section, nous nous concentrerons sur types d'exceptions en Java et les différences entre les deux.
Les exceptions peuvent être classées de deux manières :
- Exceptions intégrées
- Exception vérifiée
- Exception non vérifiée
- Exceptions définies par l'utilisateur
Exception intégrée
Des exceptions qui sont déjà disponibles dans Bibliothèques Java sont appelés exception intégrée . Ces exceptions sont capables de définir la situation d'erreur afin que nous puissions comprendre la raison de cette erreur. Il peut être classé en deux grandes catégories, à savoir exceptions vérifiées et exception non vérifiée .
Exception vérifiée
Vérifié les exceptions sont appelées moment de la compilation exceptions car ces exceptions sont vérifiées au moment de la compilation par le compilateur. Le compilateur garantit si le programmeur gère l'exception ou non. Le programmeur devrait devoir gérer l’exception ; sinon, le système a affiché une erreur de compilation.
CheckedExceptionExample.java
logique de transfert de registre
import java.io.*; class CheckedExceptionExample { public static void main(String args[]) { FileInputStream file_data = null; file_data = new FileInputStream('C:/Users/ajeet/OneDrive/Desktop/Hello.txt'); int m; while(( m = file_data.read() ) != -1) { System.out.print((char)m); } file_data.close(); } } Dans le code ci-dessus, nous essayons de lire le Bonjour.txt fichier et afficher ses données ou son contenu à l’écran. Le programme renvoie les exceptions suivantes :
- Le FileInputStream(Fichier nom de fichier) le constructeur lance le FileNotFoundException c'est une exception vérifiée.
- Le lire() méthode du FichierInputStream la classe lance le IOException .
- Le fermer() La méthode lève également l'exception IOException.
Sortir:
Comment résoudre l'erreur ?
Il existe essentiellement deux manières de résoudre ces erreurs.
1) Les exceptions se produisent dans la méthode principale. Nous pouvons nous débarrasser de ces erreurs de compilation en déclarant l'exception dans la méthode principale en utilisant les lancers Nous déclarons uniquement l'IOException, et non FileNotFoundException, en raison de la relation enfant-parent. La classe IOException est la classe parent de FileNotFoundException, cette exception sera donc automatiquement couverte par IOException. Nous déclarerons l'exception de la manière suivante :
class Exception{ public static void main(String args[]) throws IOException { ... ... } Si nous compilons et exécutons le code, les erreurs disparaîtront et nous verrons les données du fichier.
comment vérifier la taille de l'écran du moniteur
2) Nous pouvons également gérer ces exceptions en utilisant essayer-attraper Cependant, la méthode que nous avons utilisée ci-dessus n’est pas correcte. Nous devons donner un message significatif pour chaque type d'exception. En faisant cela, il serait facile de comprendre l'erreur. Nous utiliserons le bloc try-catch de la manière suivante :
Exception.java
import java.io.*; class Exception{ public static void main(String args[]) { FileInputStream file_data = null; try{ file_data = new FileInputStream('C:/Users/ajeet/OneDrive/Desktop/programs/Hell.txt'); }catch(FileNotFoundException fnfe){ System.out.println('File Not Found!'); } int m; try{ while(( m = file_data.read() ) != -1) { System.out.print((char)m); } file_data.close(); }catch(IOException ioe){ System.out.println('I/O error occurred: '+ioe); } } } Nous verrons un message d'erreur approprié 'Fichier introuvable!' sur la console car il n'y a pas de fichier de ce type à cet emplacement.
entier dans une chaîne
Exceptions non vérifiées
Le décoché les exceptions sont juste à l'opposé des vérifié des exceptions. Le compilateur ne vérifiera pas ces exceptions au moment de la compilation. En termes simples, si un programme lève une exception non vérifiée, et même si nous ne la gérons pas ou ne la déclarons pas, le programme ne générera pas d'erreur de compilation. Cela se produit généralement lorsque l’utilisateur fournit des données erronées lors de l’interaction avec le programme.
Remarque : La classe RuntimeException est capable de résoudre toutes les exceptions non vérifiées en raison de la relation enfant-parent.
UncheckedExceptionExample1.java
class UncheckedExceptionExample1 { public static void main(String args[]) { int postive = 35; int zero = 0; int result = positive/zero; //Give Unchecked Exception here. System.out.println(result); } } Dans le programme ci-dessus, nous avons divisé 35 par 0. Le code serait compilé avec succès, mais il générerait une erreur ArithmeticException au moment de l'exécution. Lors de la division d'un nombre par 0, l'exception de division par zéro est générée.
types de boucle for
Sortir:
UncheckedException1.java
class UncheckedException1 { public static void main(String args[]) { int num[] ={10,20,30,40,50,60}; System.out.println(num[7]); } } Sortir:
Dans le code ci-dessus, nous essayons d'obtenir l'élément situé à la position 7, mais la longueur du tableau est de 6. Le code se compile avec succès, mais renvoie l'exception ArrayIndexOutOfBoundsException au moment de l'exécution.
Exception définie par l'utilisateur
Dans Java , nous avons déjà des classes d'exception intégrées comme ArrayIndexOutOfBoundsException , NullPointerException , et ArithmétiqueException . Ces exceptions sont limitées à se déclencher dans certaines conditions prédéfinies. En Java, nous pouvons écrire notre propre classe d'exception en étendant la classe Exception. Nous pouvons lancer notre propre exception sur une condition particulière en utilisant le mot-clé throw. Pour créer une exception définie par l'utilisateur, nous devons avoir une connaissance de base de le essayer-attraper bloquer et lancer mot-clé .
Écrivons un Programme Java et créez une exception définie par l'utilisateur.
mysql a quitté la jointure
UserDefinedException.java
import java.util.*; class UserDefinedException{ public static void main(String args[]){ try{ throw new NewException(5); } catch(NewException ex){ System.out.println(ex) ; } } } class NewException extends Exception{ int x; NewException(int y) { x=y; } public String toString(){ return ('Exception value = '+x) ; } } Sortir:
Description:
Dans le code ci-dessus, nous avons créé deux classes, c'est-à-dire Exception définie par l'utilisateur et NouvelleException . Le Exception définie par l'utilisateur a notre méthode principale, et le NouvelleException class est notre classe d'exception définie par l'utilisateur, qui étend exception . Dans le NouvelleException classe, nous créons une variable X de type entier et attribuez-lui une valeur dans le constructeur. Après avoir attribué une valeur à cette variable, nous renvoyons le message d'exception.
Dans le Exception définie par l'utilisateur classe, nous avons ajouté un essayer-attraper bloc. Dans la section try, nous levons l'exception, c'est-à-dire : NouvelleException et passez-lui un entier. La valeur sera transmise à la classe NewException et renverra un message. Nous capturons ce message dans le bloc catch et l'affichons à l'écran.
Différence entre les exceptions cochées et non cochées
| Oui Non | Exception vérifiée | Exception non vérifiée |
|---|---|---|
| 1. | Ces exceptions sont vérifiées au moment de la compilation. Ces exceptions sont également gérées au moment de la compilation. | Ces exceptions sont juste à l'opposé des exceptions vérifiées. Ces exceptions ne sont pas vérifiées et gérées au moment de la compilation. |
| 2. | Ces exceptions sont des sous-classes directes d’exception mais non étendues à partir de la classe RuntimeException. | Ce sont les sous-classes directes de la classe RuntimeException. |
| 3. | Le code donne une erreur de compilation dans le cas où une méthode lève une exception vérifiée. Le compilateur n'est pas capable de gérer lui-même l'exception. | Le code se compile sans aucune erreur car les exceptions échappent à la notification du compilateur. Ces exceptions sont le résultat d'erreurs créées par l'utilisateur dans la logique de programmation. |
| 4. | Ces exceptions surviennent principalement lorsque la probabilité d’échec est trop élevée. | Ces exceptions sont principalement dues à des erreurs de programmation. |
| 5. | Les exceptions vérifiées courantes incluent IOException, DataAccessException, InterruptedException, etc. | Les exceptions courantes non vérifiées incluent ArithmeticException, InvalidClassException, NullPointerException, etc. |
| 6. | Ces exceptions sont propagées à l'aide du mot-clé throws. | Ceux-ci sont automatiquement propagés. |
| 7. | Il est nécessaire de fournir les blocs try-catch et try-finally pour gérer l'exception vérifiée. | Dans le cas d’une exception non cochée, ce n’est pas obligatoire. |
Les bugs ou erreurs que nous ne voulons pas et qui restreignent l'exécution normale des programmes sont appelés des exceptions .
ArithmeticException, ArrayIndexOutOfBoundExceptions, ClassNotFoundExceptions etc. entrent dans la catégorie des Exception intégrée . Parfois, les exceptions intégrées ne suffisent pas à expliquer ou à décrire certaines situations. Pour décrire ces situations, nous devons créer nos propres exceptions en créant une classe d'exceptions en tant que sous-classe du Exception classe. Ces types d'exceptions entrent dans la catégorie des Exception définie par l'utilisateur .