Quelle est l'utilisation de la méthode printStackTrace() en Java?

J'étais un peu curieux à ce sujet aussi, alors je viens de mettre en place un petit exemple de code où 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);

L'Appel println(e):

java.lang.NullPointerException

L'Appel e.printStackTrace():

java.io.IOException
      at package.Test.main(Test.java:74)

Il aide à tracer l'exception. Par exemple, vous écrivez certaines méthodes dans votre programme et l'une de vos méthodes provoque un bogue. Ensuite, printstack vous aidera à identifier la méthode qui provoque le bogue. Stack aidera comme ceci:

Tout 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 à l'intérieur d'une méthode, cette pile aidera à identifier cette méthode.

printStackTrace() aide le programmeur à comprendre où le problème réel s'est produit. printStacktrace() est une méthode de la classe Throwable de java.lang package. Il imprime plusieurs lignes dans la console de sortie. La première ligne se compose de plusieurs chaînes. Il contient le nom de la sous-classe Throwable et les informations du 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. Le deuxième dernière ligne nous informe sur la ligne suivante dans la pile où le contrôle va après avoir obtenu le transfert du numéro de ligne décrit dans 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 remplit elle-même les détails du transfert du contrôle du 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ù dans le code, le problème réel est.

Avec la printStackTrace() méthode, 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 qui a écrit le programme de voir ce qui s'est mal passé. Mais comme il montre des problèmes dans le code source, le ou les utilisateurs qui peuvent ou non avoir une expérience de codage peuvent ne pas être en mesure de comprendre ce qui a mal tourné, donc si le programme permet à l'utilisateur d'envoyer des messages d'erreur aux auteurs, les utilisateurs peuvent ne pas être en mesure de donner de bonnes

Vous devriez considérer la méthode Logger.getLogger(), il offre une meilleure fonctionnalité de gestion des exceptions (journalisation), et en outre printStackTrace() sans arguments est considéré comme obsolète et ne doit être utilisé qu'à des fins de débogage, pas pour l'affichage utilisateur.

Le printStackTrace() aide le programmeur à comprendre où le problème réel s'est produit. La méthode printStackTrace() est un membre de la classe Throwable dans le paquet java.lang.

printStackTrace est une méthode de la Throwable classe. Cette méthode affiche un message d'erreur dans la console; où nous obtenons l'exception dans le code source. Ces méthodes peuvent être utilisées avec catch block et elles décrivent:

1. Nom de l'exception.
2. Description de l'exception.
3. Emplacement de l'exception dans le code source.

Les trois méthodes qui décrivent l'exception sur la console (dans laquelle printStackTrace est l'une d'entre elles) sont:

1. printStackTrace()
2. toString()
3. getMessage()

Exemple:

public class BabluGope {
    public static void main(String[] args) {
        try {
            System.out.println(10/0);
         } catch (ArithmeticException e) {
             e.printStackTrace();   
             // System.err.println(e.toString());
             //System.err.println(e.getMessage());  
         }
    }
}

Quelle est l'utilisation de la méthode e. printStackTrace() en Java?

Eh bien, le but de l'utilisation de cette méthode e.printStackTrace(); est de voir ce qui ne va pas exactement.

Par exemple, nous voulons gérer une exception. Jetons un coup d'œil à 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 la sortie, 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)