À quoi sert la méthode printStackTrace () en Java?

Je suis en train de passer par un programme socket. Dans celui-ci, printStackTraceest appelé sur l' IOExceptionobjet dans le bloc catch.
Que fait printStackTrace()réellement?

catch(IOException ioe)
{
    ioe.printStackTrace();
}

Je ne connais pas son but. A quoi cela sert?

C'est une méthode sur les Exceptioninstances qui imprime la trace de pile de l'instance surSystem.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 produit.

Voici un exemple de la façon dont il pourrait être utilisé dans la pratique:

try {
    // ...
} catch (SomeException e) { 
    e.printStackTrace();
}

J'étais un peu curieux à ce sujet aussi, alors j'ai juste rassemblé 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);

Appel println(e):

java.lang.NullPointerException

Appel e.printStackTrace():

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

Cela aide à retracer l'exception. Par exemple, vous écrivez des méthodes dans votre programme et l'une de vos méthodes provoque un bogue. Ensuite, printstack vous aidera à identifier la méthode à l'origine du 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 dans 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 Throwablede java.langpackage. 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 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 / l'exception. L'avant-dernière ligne nous informe de 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 fillInStackTrace()méthode de la Throwableclasse, qui remplit elle-même les détails du transfert de contrôle du programme dans la pile d'exécution. Les lignes commençant par at, ne sont que les valeurs de la pile d'exécution. De cette façon, le programmeur peut comprendre où se trouve dans le code le problème réel.

Avec la printStackTrace()méthode, c'est une bonne idée à 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 n'a pas fonctionné. Mais comme il présente 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 ne va pas, donc 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 n'a pas fonctionné.

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

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

printStackTraceest une méthode de la Throwableclasse. 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 le bloc catch 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());  
         }
    }
}

printStackTrace () aide le programmeur à comprendre où le problème réel s'est produit. Cela aide à retracer l'exception. c'est la méthode printStackTrace () de la classe Throwable héritée par 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.

Ce qui suit est 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: Ceci est une nouvelle exception en Java ... à ClassName.methodName (fileName: 5)

À quoi sert 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.

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é une méthode e.printStackTrace();pour 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)

printStackTrace() indique à quelle ligne vous obtenez une erreur et pourquoi vous obtenez une erreur.

Exemple:

 java.lang.ArithmeticException: / by zero
    at MinNumber.main(MinNumber.java:8)