Cet article est un compte rendu de ce que je comprends pour ceux qui étudient Java.
Les fonctions Java et les méthodes de description sont décrites dans la liste suivante. Cette fois, il s'agit de la gestion des exceptions.
L'idée de la gestion des exceptions est de décrire la réponse à l'avance au cas où un comportement inattendu se produirait dans le code et qu'une exception se produirait.
Une exception est un événement anormal lors de l'exécution du programme. Il est souvent mélangé avec Error, mais c'est complètement différent. Error est un événement anormal qui ne peut pas être géré même sur une machine virtuelle et qui sera interrompu de force, de sorte que la gestion des exceptions ne peut pas le gérer. La seule exception est que vous pouvez poursuivre le programme sans terminer l'opération.
Je vais expliquer l'instruction try ~ catch.
class Main{
public static void main(String args[]){
try{
int[] array = {0,1,2};
System.out.println(array[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("J'ai une exception");
}
}
}
La description ci-dessus est sous la forme de try ~ catch. En tant que mécanisme, lorsque la même exception que la classe catch se produit dans try and catch, l'instruction d'exception est transmise à catch (instruction d'exception) et le contenu de catch fonctionne. C'est facile à comprendre si vous pensez que c'est presque comme ça.
Lorsque vous compilez et exécutez
J'ai une exception
Est affiché. Le contenu de catch bouge.
Les exceptions cochées sont le traitement des exceptions utilisé pour le traitement qui ne fonctionne pas sauf si le traitement des exceptions est inclus. Je pense que c'est difficile à imaginer avec ces mots, je vais donc le décrire.
Le code ci-dessous ne gère aucune exception.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class Main{
public static void main(String args[]){
BufferedReader bufferReader = null;
FileReader fileReaderr = null;
//Fichier d'entrée
fileReaderr = new FileReader("test.txt");
bufferReader = new BufferedReader(fileReaderr);
//Lire ligne par ligne et sortie
String line;
while ((line = bufferReader.readLine()) != null) {
System.out.println(line);
//Fermer intentionnellement le flux et lever une IOException
bufferReader.close();
}
}
}
Quand j'essaye de compiler ceci
test.java:11:Erreur:L'exception FileNotFoundException n'est pas signalée. Doit être capturé ou déclaré lancer
fileReaderr = new FileReader("test.txt");
^
test.java:16:Erreur:L'exception IOException n'est pas signalée. Doit être capturé ou déclaré lancer
while ((line = bufferReader.readLine()) != null) {
^
test.java:21:Erreur:L'exception IOException n'est pas signalée. Doit être capturé ou déclaré lancer
bufferReader.close();
^
Cela peut être un peu difficile à voir, mais la description ci-dessus est une nuance qui dit que ce comportement ne fonctionnera pas sans la gestion des exceptions.
IOException ne permet pas la compilation sans traitement des exceptions. Donc IOException est la cible des exceptions vérifiées.
Alors, fermons la partie où ces opérations sont effectuées avec try ~ catch.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class Main{
public static void main(String args[]){
BufferedReader bufferReader = null;
FileReader fileReaderr = null;
try {
//Fichier d'entrée
fileReaderr = new FileReader("test.txt");
bufferReader = new BufferedReader(fileReaderr);
//Lire ligne par ligne et sortie
String line;
while ((line = bufferReader.readLine()) != null) {
System.out.println(line);
//Fermer intentionnellement le flux et lever une IOException
bufferReader.close();
}
} catch (IOException e) {
System.out.println("IOException se produit");
}
}
}
Si vous compilez et exécutez ceci
IOException se produit
En lisant le fichier txt dans le processus et en le mettant fin de force dans while, une IOException se produira dans try. À ce moment-là, la gestion des exceptions fonctionne et l'opération de sortie dans catch est effectuée.
Vous pouvez également éliminer les erreurs de compilation en définissant des lancers dans la méthode.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class Main{
public static void main(String args[]) throws IOException{
BufferedReader bufferReader = null;
FileReader fileReaderr = null;
//Fichier d'entrée
fileReaderr = new FileReader("test.txt");
bufferReader = new BufferedReader(fileReaderr);
//Lire ligne par ligne et sortie
String line;
while ((line = bufferReader.readLine()) != null) {
System.out.println(line);
//Fermer intentionnellement le flux et lever une IOException
bufferReader.close();
}
}
}
Vous pouvez également compiler avec cette description. Même avec cette description, vous pouvez suivre les exceptions de vérification. Courez
Exception in thread "main" java.io.FileNotFoundException: test.txt (No such file or directory)
at java.base/java.io.FileInputStream.open0(Native Method)
at java.base/java.io.FileInputStream.open(FileInputStream.java:212)
at java.base/java.io.FileInputStream.<init>(FileInputStream.java:154)
at java.base/java.io.FileInputStream.<init>(FileInputStream.java:109)
at java.base/java.io.FileReader.<init>(FileReader.java:60)
at Main.main(test.java:11)
Une exception se produira pendant l'exécution et le traitement prendra fin. La différence avec try ~ catch est qu'il n'y a pas de suivi (catch) lorsqu'une exception se produit.
En ce qui concerne le flux de traitement, IOException a été émise en premier pour try ~ catch, et à ce stade, le processus de l'instruction catch a été ignoré, de sorte qu'une autre exception ne s'est pas produite.
Étant donné que les levées sont uniquement dans l'état où IOException est autorisée à ce stade, cela signifie qu'une autre exception se produit après cela et le programme est terminé. Les lancers sont décrits en détail dans un autre élément, veuillez donc y jeter un œil également.
En passant, j'ai entendu dire que Java est le seul à avoir le concept d'exceptions vérifiées. Donc, si vous venez d'une autre langue, vous pouvez être confus par l'erreur qui apparaît même si le processus est correct.
C'est une forme courante dans d'autres langages, et c'est une exception arbitraire qui décrit la gestion des exceptions. Cette fois, je vérifierai avec ArrayIndexOutOfBoundsException (accès à des éléments qui n'existent pas dans le tableau).
Ceci est une description sans traitement d'exception.
class Main{
public static void main(String args[]){
int[] array = {0,1,2};
System.out.println(array[3]);
}
}
J'essaie de référencer le troisième du tableau de tableau dans la sortie, mais il n'y a que 0 ~ 2 tableaux. Mais cela ne provoque pas d'erreur de compilation, et quand je l'exécute
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
at Main.main(test.java:6)
J'ai une ArrayIndexOutOfBoundsException. On m'a dit que j'essayais de regarder en dehors de la portée du tableau.
Maintenant, mettons dans la gestion des exceptions et laissez-le fonctionner. Il s'agit du code décrit dans le mécanisme de gestion des exceptions d'en-tête.
Compile tout comme courir
J'ai une exception
J'ai pu afficher le message dans l'instruction catch.
Les exceptions non contrôlées sont essentiellement des erreurs évitables et ne sont pas obligatoires. J'ai l'impression que c'est plutôt nuancé au cas où.
finally J'introduirai également le cas de la mise enfin après prise.
class Main{
public static void main(String args[]){
try{
int[] array = {0,1,2};
System.out.println(array[2]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("J'ai une exception");
}finally{
System.out.println("Fonctionne avec soit");
}
}
}
C'est un processus qui ne donne pas d'exception, mais quand il est compilé et exécuté
2
Fonctionne avec soit
Le traitement enfin fonctionne aussi comme ça. Cette fois, je vais l'essayer avec la description qui fait une exception.
class Main{
public static void main(String args[]){
try{
int[] array = {0,1,2};
System.out.println(array[3]);
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("J'ai une exception");
}finally{
System.out.println("Fonctionne avec soit");
}
}
}
Lorsque vous compilez et exécutez
J'ai une exception
Fonctionne avec soit
L'affichage ressemble à ceci. De cette façon, il est affiché en essai indépendamment de la présence ou de l'absence d'exceptions. Dans les deux cas, le processus que vous souhaitez déplacer et se produire sera décrit ici.
throw Jusqu'à présent, nous avons suivi le traitement des exceptions dans le flux d'exécution de cette opération lorsqu'une exception se produit, mais vous pouvez effectuer le traitement des exceptions vous-même (en termes de termes, lever une exception) avec l'instruction throw.
Décrivons d'abord le lancer.
class Main{
public static void main(String args[]){
System.out.println("Lancer d'exception");
try{
throw new Exception("Lancer une exception");
}catch(Exception e){
System.out.println("Gestion des exceptions");
}
}
}
Quand tu cours
Lancer d'exception
Gestion des exceptions
Ce processus est en cours d'essai
throw new IOException("Lancer une exception");
Travaille. Une exception est émise avec cette description et l'instruction catch la complète, ce qui donne deux sorties.
throws throws est une spécification selon laquelle l'appelant de méthode effectue le traitement des exceptions lorsqu'une exception se produit. Je pense que c'est difficile à imaginer avec ces mots, je vais donc les décrire ici aussi.
class Main{
public static void main(String args[]){
System.out.println("Lancer d'exception");
try{
Main.mikan();
}catch(Exception e){
System.out.println("Gestion des exceptions");
}
}
static void mikan() throws Exception{
throw new Exception("Lancer une exception");
}
}
Lorsque vous compilez et exécutez
Lancer d'exception
Gestion des exceptions
Il sera affiché. En tant que flux d'opération, la méthode mikan est appelée dans l'instruction try de la méthode main.
Une exception throws est définie dans la méthode mikan appelée. En termes simples, cela signifie que si une exception est émise dans une méthode, elle sera transmise à l'appelant.
Puisque nous émettons une exception dans la méthode, nous lèverons l'exception à l'appelant. Catch le complète et la sortie de la gestion des exceptions se déplace.
Toutefois, dans cet exemple, par souci de facilité d'image, le traitement des exceptions est complété par catch, mais lors de son écriture, il est préférable de décrire l'exception qui peut se produire avec cette méthode. pense. Par conséquent, l'exemple ici est décrit pour recevoir IOException (vérifier l'exception).
Il convient de noter dans les lancers que si la méthode est définie pour lancer une exception vérifiée, une erreur se produira si l'appelant ne comprend pas try ~ catch, et si throws n'est pas défini, essayez ~ catch C'est une erreur même si l'appelant est entouré de. Ceci est également décrit.
Ici, l'appelant de méthode est inclus dans try ~ catch, mais le côté méthode ne définit pas les throws.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class Main{
public static void main(String args[]){
try{
Main.mikan();
}catch(IOException e){
System.out.println("Je reçois une IOException");
}
}
static void mikan(){
BufferedReader bufferReader = null;
FileReader fileReaderr = null;
//Fichier d'entrée
fileReaderr = new FileReader("test.txt");
bufferReader = new BufferedReader(fileReaderr);
//Lire ligne par ligne et sortie
String line;
while ((line = bufferReader.readLine()) != null) {
System.out.println(line);
//Fermer intentionnellement le flux et lever une IOException
bufferReader.close();
}
}
}
Quand j'essaye de compiler ceci
test.java:9:Erreur:Exception IOException n'est pas levée dans le corps de l'instruction try correspondante
}catch(IOException e){
^
test.java:18:Erreur:L'exception FileNotFoundException n'est pas signalée. Doit être capturé ou déclaré lancer
fileReaderr = new FileReader("test.txt");
^
test.java:23:Erreur:L'exception IOException n'est pas signalée. Doit être capturé ou déclaré lancer
while ((line = bufferReader.readLine()) != null) {
^
test.java:27:Erreur:L'exception IOException n'est pas signalée. Doit être capturé ou déclaré lancer
bufferReader.close();
^
4 erreurs
Une erreur s'affiche. Les trois erreurs du bas sont similaires aux erreurs lorsqu'elles ne sont pas incluses dans try ~ catch, et sont des erreurs pour l'état où il semble que la correspondance de IOException n'est pas décrite même s'il s'agit d'une exception vérifiée.
L'erreur ci-dessus est une erreur qui indique que IOException ne se produit pas dans try ~ catch. Cela se produit en fait dans la méthode, mais comme il n'est pas déclaré, le côté essai ne peut pas le confirmer.
Ensuite, il n'y a pas de description de try ~ catch dans l'appelant de la méthode, vérifions donc l'opération avec la personne qui définit les lancers dans la méthode.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class Main{
public static void main(String args[]){
Main.mikan();
}
static void mikan() throws IOException{
BufferedReader bufferReader = null;
FileReader fileReaderr = null;
//Fichier d'entrée
fileReaderr = new FileReader("test.txt");
bufferReader = new BufferedReader(fileReaderr);
//Lire ligne par ligne et sortie
String line;
while ((line = bufferReader.readLine()) != null) {
System.out.println(line);
//Fermer intentionnellement le flux et lever une IOException
bufferReader.close();
}
}
}
Ce code est une copie du processus qui doit être inclus dans try dans l'exemple d'exception de vérification de la méthode mikan. Quand j'essaye de compiler ceci
L'exception IOException n'est pas signalée. Doit être capturé ou déclaré lancer
Main.mikan();
^
J'obtiens une erreur. C'est le contraire de la précédente, et il est connu d'après la définition de throws qu'une IOException se produira du côté de l'appelant, mais c'est une erreur que vous devez la placer dans try ~ catch car c'est une exception vérifiée.
Insérez l'exemple ci-dessus dans une instruction try.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class Main{
public static void main(String args[]){
try{
Main.mikan();
}catch(IOException e){
System.out.println("Je reçois une IOException");
}
}
static void mikan() throws IOException{
BufferedReader bufferReader = null;
FileReader fileReaderr = null;
//Fichier d'entrée
fileReaderr = new FileReader("test.txt");
bufferReader = new BufferedReader(fileReaderr);
//Lire ligne par ligne et sortie
String line;
while ((line = bufferReader.readLine()) != null) {
System.out.println(line);
//Fermer intentionnellement le flux et lever une IOException
bufferReader.close();
}
}
}
Maintenant, lorsque vous compilez et exécutez
Je reçois une IOException
Il sera affiché. Une exception s'est produite dans la méthode mikan et l'appelant a pu capturer et traiter la sortie dans l'instruction catch. S'il y a des exceptions cochées définies dans les lancers, faites attention à la description de l'appelant.
J'ai décrit diverses exceptions. Comme je l'ai mentionné un peu ci-dessus, si vous étudiez Java, vous devriez vérifier les exceptions cochées pour traiter l'erreur.
Recommended Posts