La machine virtuelle Java (ci-après JVM) traite le code et exécute les méthodes les unes après les autres, en commençant par la méthode
main
. Lorsqu'il atteint la méthode suivante, il indique que cette méthode se trouve en haut de la pile. Une fois qu’une méthode est entièrement exécutée, elle est supprimée de la pile et remplacée par la suivante dans la file d’attente. Pour démontrer le principe, tapez ce code :
package errorhandling;
public class errorChecking {
public static void main(String[] args) {
System.out.println("Метод Main успешно запущен");
m1();
System.out.println("Метод Main заканчивает свою работу");
}
static void m1() {
System.out.println("Первый метод передаёт привет!(m1)");
m2();
}
static void m2() {
System.out.println("Второй метод передаёт привет(m2)");
}
}
Nous avons trois méthodes : méthode main
, méthode m1
et méthode m2
. Au démarrage du programme, la méthode est située en haut de la pile main
. À l'intérieur de la méthode main
, la méthode est appelée m1
. Lorsqu'il est appelé, il saute en haut de la pile. La méthode m1
appelle à son tour le m2
. La méthode m2
passe désormais au sommet de la pile, supprimant temporairement m1
. Imaginez cela une seconde - main
au-dessus m1
et au-dessus m2
! Après avoir fait ses affaires, m2
il se termine et le contrôle revient à m1
. La méthode m1
, une fois terminée, est également supprimée de la pile et le contrôle est à nouveau donné à la méthode main
. Exécutez votre programme et regardez la fenêtre de sortie : La méthode Main s'exécute avec succès La première méthode dit bonjour!(m1) La deuxième méthode dit bonjour(m2) La méthode Main se termine Si quelque chose ne va pas dans la méthode m2
, la JVM (Java Virtual Machine ), vous vous en souvenez, n'est-ce pas ?) recherchera des gestionnaires d'erreurs, par exemple un block try … catch
. S'il n'y a aucune erreur dans la m1
méthode du gestionnaire d'erreurs, alors l'exception sera transmise à la méthode m1
, dans l'espoir qu'elle sera capable de la gérer. S'il ne détecte pas de gestionnaire d'erreurs ici, l'exception remontera à nouveau dans la pile, cette fois vers la méthode main
. Si la méthode main
ne détecte pas l'exception, vous obtiendrez un étrange message d'erreur imprimé dans la fenêtre de sortie. À titre d'exemple, faites en sorte que votre méthode m2
ressemble à ceci :
static void m2() {
int x = 10;
int y = 0;
double z = x / y;
System.out.println( z );
System.out.println("Method Two - m2");
}
Cette méthode contient une division par zéro erreur. Voici la version complète du programme, vérifiez auprès du vôtre :
package errorhandling;
public class errorChecking {
public static void main(String[] args) {
System.out.println("Метод Main успешно запущен");
m1();
System.out.println("Метод Main заканчивает свою работу");
}
static void m1() {
System.out.println("Первый метод передаёт привет!(m1)");
m2();
}
static void m2() {
int x = 10;
int y = 0;
double z = x / y;
System.out.println( z );
System.out.println("Method Two - m2");
}
}
Exécutez le programme et voyez ce que la fenêtre de sortie vous donne : La méthode Main s'est exécutée avec succès La première méthode dit bonjour !(m1) Exception dans le thread "main" java.lang.ArithmeticException : / par zéro à errorhandling.errorChecking.m2(<u >errorChecking. java:17</u>) à errorhandling.errorChecking.m1(<u>Solution.java:11</u>) à errorhandling.errorChecking.main(<u>>Solution.java:5</u >) Processus terminé avec le code de sortie 1 Vous regardez quelque chose appelé une trace de pile. Les trois lignes soulignées en bleu font référence à vos méthodes et se trouvent dans : Name_пакета.Name_класса.Name_метода
La première ligne en partant du haut est l'endroit où l'erreur s'est produite - dans la méthode m2
. Java a veillé à ce qu'il soit géré de manière ArithmeticException
à détecter la division par zéro erreur. Il n’y a pas de gestionnaire d’erreurs dans les méthodes m2
, m1
et . main
Le programme l'a donc traité avec le gestionnaire d'erreurs par défaut. Modifiez votre méthode m1
comme suit :
try {
System.out.println("Первый метод передаёт привет!(m1)");
m2( );
}
catch (ArithmeticException err) {
System.out.println(err.getMessage());
}
Nous avons maintenant enveloppé la méthode m2
dans un bloc try
. Nous utilisons en partie catch
le type d'exception qui a été détecté dans la pile trace- ArithmeticException
. Exécutez à nouveau le code et vous verrez ce qui suit dans la fenêtre de sortie : La méthode Main s'est exécutée avec succès La première méthode dit bonjour ! (m1) / par zéro La méthode Main se termine Notez que le message d'erreur a été imprimé comme : " / par zéro " . La méthode m2
ne s'est pas exécutée complètement, mais a été arrêtée lorsqu'une erreur s'est produite. Le contrôle a ensuite été restitué m1
. Cela est dû au fait que le bloc catch
lui-même a reconnu l'erreur : la JVM n'a pas contacté le gestionnaire d'erreurs standard, mais a affiché un message situé entre les accolades du bloc catch
. Veuillez noter que le programme lui-même n'a pas été arrêté. Le contrôle, comme d'habitude, est allé à la méthode main
à partir de laquelle m1
il a été appelé. Et la dernière ligne de la méthode main
a pu afficher « End Main method ». C'est très très important. Si vous aviez besoin de la valeur de m1
, pour un travail ultérieur quelque part dans main
. Et si la valeur n’est pas là, votre programme risque de ne pas fonctionner du tout comme prévu. Lorsque vous voyez la trace de la pile dans la fenêtre de sortie, sachez simplement que la première ligne correspond à l'endroit où le problème s'est produit et que les lignes restantes (s'il y en a bien sûr) sont l'endroit où l'exception a été propagée dans la pile, se terminant généralement par le main
. Traduction de homeandlearn.co.uk Nous disons merci à : Sergei Sysoev, Treefeed...
GO TO FULL VERSION