Fait référence à un problème qui se produit pendant l'exécution du programme.
--Bugs créés par des programmeurs négligemment
Il existe différents types tels que, mais le logiciel utilisé par l'utilisateur ne s'arrête pas, ne cesse de fonctionner, ou même s'il fonctionne, il ne fonctionne pas normalement même en cas de problème. Ne pas. Par conséquent, les programmeurs doivent ** «programmer en cas d'urgence **» pour faire face à diverses situations. On peut dire que cette gestion des exceptions joue un rôle qui lui correspond.
try、catch、finally
Placez le traitement susceptible de provoquer une exception dans un bloc try et décrivez le traitement lorsqu'une exception se produit dans le bloc catch qui suit le bloc try.
try Plusieurs instructions peuvent être écrites dans le bloc try. Si une exception se produit, le traitement suivant dans le bloc try est ignoré ** et le contrôle est immédiatement transféré vers le bloc catch correspondant. Une fois le contrôle transféré au bloc catch, le traitement du bloc try suivant ne sera pas exécuté indépendamment de la nécessité.
catch Le bloc catch est un bloc pour décrire le traitement lorsqu'une exception se produit. ** Le but du bloc catch est de ramener le programme à l'état normal **, et lorsque le traitement de ce bloc est terminé, "le problème a été résolu et le fonctionnement normal est rétabli. Puisqu'une pluralité de blocs de capture peut être décrite pour chaque type d'exception qui s'est produite, le processus de traitement peut être modifié pour chaque type d'exception.
Il est également possible d'omettre le bloc catch. L'omission du bloc catch est un cas où la méthode ne peut pas déterminer comment gérer l'exception.
Lors de la préparation de plusieurs blocs catch, ** Si vous écrivez du code qui ne peut pas être atteint quel que soit le modèle d'exceptions, le compilateur générera une erreur de compilation. ** **
[Exemple de cas inaccessible]
SampleException
public class SampleException extends Exception{}
SubSampleException
public class SubSampleException extends SampleException{}
Main
public class Main {
public static void main(String[] args) {
try {
sample();
sub();
} catch (SampleException e) {
System.out.println("A");
} catch (SubSampleException e) {
System.out.println("B");
}
}
private static void sample() throws SampleException {
throw new SampleException();
}
private static void sub() throws SubSampleException{
}
Main method Appelle la méthode sample () sur la première ligne du bloc try → catch (SampleException e) {} Reçoit le bloc et effectue le traitement du contenu décrit dans le bloc.
Dans la deuxième ligne de la méthode main, appelez la méthode sub () → ** catch (SampleException e) {} Block ** reçoit et effectue le traitement du contenu décrit dans le bloc. Attrapez avec la superclasse SampleException avant d'atteindre SubSampleException.
Donc,
[Résultat de sortie] A A
Voilà le résultat.
SubSampleException est levée en appelant la méthode sub () sur la deuxième ligne du bloc try, mais comme la classe SampleException est une superclasse de la classe SubSampleException, le bloc SampleException peut également intercepter cette exception. Par conséquent, le traitement est effectué dans le bloc reçu par la classe SampleException écrite précédemment avant que le bloc reçoive l'exception par SubSampleException.
Dans un tel cas, le bloc catch dans SubSampleException est déterminé comme étant du code inaccessible et le compilateur lèvera une erreur de compilation.
finally
Indépendamment du fait qu'une exception se produise ou non, le processus à exécuter existe quelle que soit la forme du programme. Le bloc finally sert à décrire le traitement que vous souhaitez exécuter, qu'une exception se soit produite ou non.
Lorsque le bloc finally est décrit, si aucune exception ne se produit, le processus décrit dans le bloc finally est exécuté après l'exécution du bloc try. Si une exception se produit, le contrôle est transféré du bloc try au bloc catch, puis le bloc finally est exécuté.
Le bloc finally sert à décrire le processus que vous souhaitez exécuter indépendamment du fait qu'une exception se soit produite, et c'est la même chose même s'il est retourné dans le bloc ** catch, et retourne le contrôle à la méthode appelante. Avant, le bloc finally est toujours exécuté. ** **
Le bloc finally n'a pas besoin d'être séparé par type d'exception.
Le bloc finally n'est pas exécuté uniquement ** lorsque la méthode System.exit est appelée dans le bloc try ou catch pour forcer l'arrêt de l'application, ou lorsque la JVM ou le système d'exploitation plante **.
→ Par conséquent, l'ordre ne peut pas être changé comme catch-try-finally et try-finally-catch.
sample
public class Main {
public static void main(String[] args) {
try {
try {
String[] array = { "A", "B", "C" };
System.out.println(array[3]); //①
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("D"); //②
} finally {
System.out.println("E"); //③
}
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("F");
} finally {
System.out.println("G"); //④
}
}
}
Lorsque plusieurs try-catch sont imbriqués de cette manière, c'est ** le bloc catch le plus proche qui correspond à l'exception qui reçoit l'exception levée. ** **
Donc, dans le code ci-dessus, (1) Puisqu'une tentative a été faite pour sortir la quatrième valeur pour un tableau de tableau qui n'a que trois valeurs dans le bloc try, le contrôle a été transféré au bloc cacth. (2) Après traitement avec le bloc catch le plus proche correspondant à l'exception survenue dans (1) ③ Effectuer le traitement dans le bloc finally interne, ④ Enfin, les processus externes de blocage final.
Cela devient le flux. À ce stade, le bloc ** finally est toujours exécuté, de sorte que les processus finalement interne et externe sont exécutés. ** **
Le traitement des exceptions Java comprend des traitements appelés "throw" et "throws". Les deux signifient «jeter» le processus, mais le contenu est très différent.
throw Lève intentionnellement une exception pour gérer l'exception. ** Décrivez dans la méthode. ** **
example
void sample (int num) {
if(num < 0) {
throw new IllegalArgumentException("Les valeurs négatives ne peuvent pas être utilisées.");
}
}
throws Les exceptions qui se produisent dans une méthode ne sont pas traitées dans ** propre méthode, mais sont gérées par l'appelant de la méthode. ** ** Le traitement des exceptions n'est pas décrit dans la méthode dans laquelle throws est écrit, et le traitement des exceptions est effectué dans la méthode du côté qui a appelé la méthode dans laquelle throws est écrit.
example
public static void sample() throws IOException{
FileWriter fw = new FileWriter("data.txt");
}
FileWriter est une classe simple pour écrire des fichiers de caractères, et si elle n'est pas interceptée par l'instruction try-catch, cela entraînera une erreur de compilation ** Check exception **, il est donc nécessaire d'écrire une instruction try-catch lors du traitement. Cependant, en décrivant les lancers, l'appelant de la méthode la fait correspondre.
Il existe deux principaux types de problèmes qui surviennent lors de l'exécution du programme en Java.
--Erreurs indiquant que le programme ne peut pas traiter des problèmes tels que des problèmes dans l'environnement d'exécution --Exceptions que le programme peut gérer
Il y en a deux.
Les exceptions sont divisées en exceptions cochées et non cochées.
--Exception vérifiée Exception que le compilateur vérifie si le traitement des exceptions est décrit (try-catch est requis)
Java est basé sur des exceptions vérifiées pour empêcher les programmeurs d'oublier d'écrire la gestion des exceptions. Dans l'histoire des logiciels devenant énormes et compliqués, le nombre d'erreurs que les programmeurs oublient de décrire la gestion des exceptions a augmenté, et le contexte est que la fonction de vérification automatique par le compilateur a été incorporée à partir de la réflexion qui a causé le bogue. ..
Les classes d'exceptions Java sont grossièrement divisées
Il est divisé en et représente respectivement une erreur, une exception vérifiée et une exception non vérifiée.
Toutes les sous-classes de la classe Exception sont des exceptions vérifiées, à l'exception de ** RuntimeException et de ses sous-classes. ** ** Par conséquent, les classes d'exception qui héritent de la classe Exception sont forcées à essayer-catch ou à déclarer dans la clause throws. D'un autre côté, ** RuntimeException et ses sous-classes sont traitées comme des exceptions non vérifiées même si elles sont des sous-classes d'Exception. ** (RuntimeException est une sous-classe d'Exception) Par conséquent, RuntimeException et ses sous-classes ne sont pas forcés de try-catch. Bien sûr, vous pouvez écrire un try-catch sans être forcé. De plus, les exceptions non cochées ** n'ont pas d'importance si elles ne sont pas déclarées dans la clause throws. ** **
L'erreur est représentée par la classe Error, mais ** c'est la sous-classe qui est réellement utilisée. ** ** Par exemple, les sous-classes qui héritent de Error incluent OutOfMemoryError, NoClassDefFoundError et StackOverflowError. De plus, pour être classé comme ** error, il est nécessaire d'hériter de Error. ** ** Lorsque ces problèmes surviennent, la machine virtuelle Java crée une instance de la sous-classe Error correspondante et avertit le programme. Il s'agit du même mécanisme que les exceptions, mais ** les erreurs ne doivent pas être "programmées" contrairement aux exceptions. ** Par conséquent, il n'est pas nécessaire de try-catch ou de déclarer avec des lancers. (Il n'est que "non requis" et peut être capturé et traité si nécessaire.)
―― Quels types d'exceptions chaque classe prend-elle en charge? --S'il correspond à une exception vérifiée ou à une exception non vérifiée
Pour etc.
Spécification de l'API Java SE 8 https://docs.oracle.com/javase/jp/8/docs/api/ Vous pouvez vérifier les détails à partir de.
Recommended Posts