Je vais à travers un programme de socket. Dans celui-ci, printStackTrace
est appelé sur l'objet IOException
dans le bloc catch.
Que fait réellement printStackTrace()
?
catch(IOException ioe)
{
ioe.printStackTrace();
}
Je ne suis pas au courant de son but. A quoi cela sert?
C'est une méthode sur les instances Exception
qui affiche la trace de pile de l'instance sur System.err
.
C'est un outil très simple, mais très utile pour diagnostiquer une exception. Il vous dit ce qui s'est passé et où, dans le code, cela s'est passé.
Voici un exemple d'utilisation pratique:
try {
// ...
} catch (SomeException e) {
e.printStackTrace();
}
J'étais un peu curieux à propos de cela aussi, alors je viens de mettre sur pied un petit exemple de code dans lequel vous pouvez voir ce qu'il fait:
try {
throw new NullPointerException();
}
catch (NullPointerException e) {
System.out.println(e);
}
try {
throw new IOException();
}
catch (IOException e) {
e.printStackTrace();
}
System.exit(0);
Appel println(e)
:
Java.lang.NullPointerException
Appel e.printStackTrace()
:
Java.io.IOException at package.Test.main(Test.Java:74)
Cela aide à tracer l'exception. Par exemple, vous écrivez des méthodes dans votre programme et une de vos méthodes provoque un bogue. Ensuite, printstack vous aidera à identifier la méthode qui cause le bogue. Stack aidera comme ceci:
D'abord, votre méthode principale sera appelée et insérée dans la pile, puis la deuxième méthode sera appelée et insérée dans la pile dans l'ordre LIFO et si une erreur se produit quelque part dans une méthode, cette pile aidera à l'identifier.
printStackTrace()
aide le programmeur à comprendre où le problème est survenu. printStacktrace()
est une méthode de la classe Throwable
du package Java.lang
. Il imprime plusieurs lignes dans la console de sortie. La première ligne est composée de plusieurs chaînes. Il contient le nom de la sous-classe Throwable et les informations sur le package. À partir de la deuxième ligne, il décrit la position d'erreur/le numéro de ligne commençant par at
.
La dernière ligne décrit toujours la destination affectée par l'erreur/exception. L'avant-dernière ligne nous informe de la prochaine ligne de la pile où le contrôle est placé après le transfert du numéro de ligne décrit à la dernière ligne. Les erreurs/exceptions représentent la sortie sous la forme d'une pile, qui ont été introduites dans la pile par la méthode fillInStackTrace()
de la classe Throwable
, qui complète elle-même les détails du transfert de contrôle de programme dans la pile d'exécution. Les lignes commençant par at
ne sont rien d'autre que les valeurs de la pile d'exécution. De cette façon, le programmeur peut comprendre où se trouve le problème dans le code.
Avec la méthode printStackTrace()
, c'est une bonne idée d'utiliser e.getmessage()
.
printStackTrace()
imprime les emplacements où l'exception s'est produite dans le code source, permettant ainsi à l'auteur du programme de voir ce qui s'est mal passé. Mais comme il présente des problèmes dans le code source, le ou les utilisateurs qui n’ont peut-être pas une expérience de codage risquent de ne pas être en mesure de comprendre ce qui a mal tourné. Ainsi, si le programme permet à l’utilisateur d’envoyer des messages d’erreur aux auteurs, le les utilisateurs peuvent ne pas être en mesure de donner de bonnes données sur ce qui a mal tourné.
Vous devriez envisager la méthode Logger.getLogger()
, qui offre une meilleure fonctionnalité de gestion des exceptions (journalisation). Outre printStackTrace()
sans arguments, elle est considérée comme obsolète et ne devrait être utilisée UNIQUEMENT qu'à des fins de débogage, et non pour l'affichage par l'utilisateur.
La printStackTrace()
aide le programmeur à comprendre où le problème est survenu. La méthode printStackTrace()
est membre de la classe Throwable
dans le package Java.lang
.
Quelle est l'utilisation de la méthode e.printStackTrace () en Java?
Bien, le but de cette méthode e.printStackTrace();
est de voir ce qui ne va pas.
Par exemple, nous voulons gérer une exception. Voyons l'exemple suivant.
public class Main{
public static void main(String[] args) {
int a = 12;
int b = 2;
try {
int result = a / (b - 2);
System.out.println(result);
}
catch (Exception e)
{
System.out.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
}
J'ai utilisé la méthode e.printStackTrace();
afin de montrer exactement ce qui ne va pas.
Dans le résultat, nous pouvons voir le résultat suivant.
Error: / by zero
Java.lang.ArithmeticException: / by zero
at Main.main(Main.Java:10)
at Sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at Sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.Java:62)
at Sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.Java:43)
at Java.lang.reflect.Method.invoke(Method.Java:498)
at com.intellij.rt.execution.application.AppMain.main(AppMain.Java:147)
printStackTrace () aide le programmeur à comprendre où le problème est survenu. Il est utile de tracer l'exception . Il s'agit de la méthode printStackTrace () de la classe Throwable héritée de chaque classe d'exception Cette méthode imprime le même message de l'objet e ainsi que le numéro de ligne où l'exception s'est produite.
Voici un autre exemple de pile d'impression de l'exception en Java.
public class Demo {
public static void main(String[] args) {
try {
ExceptionFunc();
} catch(Throwable e) {
e.printStackTrace();
}
}
public static void ExceptionFunc() throws Throwable {
Throwable t = new Throwable("This is new Exception in Java...");
StackTraceElement[] trace = new StackTraceElement[] {
new StackTraceElement("ClassName","methodName","fileName",5)
};
t.setStackTrace(trace);
throw t;
}
}
Java.lang.Throwable: il s'agit d'une nouvelle exception en Java ... à NomClasse.NomMéthode (NomFichier: 5)