Qual è l'uso del metodo printStackTrace () in Java?

Sto eseguendo un programma socket. In esso, printStackTraceviene richiamato l' IOExceptionoggetto nel blocco catch.
Cosa fa printStackTrace()effettivamente?

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

Non sono a conoscenza del suo scopo. A cosa serve?

È un metodo sulle Exceptionistanze che stampa la traccia dello stack dell'istanza suSystem.err .

È uno strumento molto semplice, ma molto utile per diagnosticare un'eccezione. Ti dice cosa è successo e dove nel codice è successo.

Ecco un esempio di come potrebbe essere utilizzato nella pratica:

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

Ero un po 'curioso anche di questo, quindi ho appena messo insieme un piccolo codice di esempio in cui puoi vedere cosa sta facendo:

try {
    throw new NullPointerException();
}
catch (NullPointerException e) {
    System.out.println(e);
}

try {
    throw new IOException();
}
catch (IOException e) {
    e.printStackTrace();
}
System.exit(0);

Chiamando println(e):

java.lang.NullPointerException

Chiamando e.printStackTrace():

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

Aiuta a rintracciare l'eccezione. Ad esempio, stai scrivendo alcuni metodi nel tuo programma e uno dei tuoi metodi causa un bug. Quindi printstack ti aiuterà a identificare quale metodo causa il bug. Stack aiuterà in questo modo:

Per prima cosa il tuo metodo principale verrà chiamato e inserito nello stack, quindi il secondo metodo verrà chiamato e inserito nello stack in ordine LIFO e se si verifica un errore da qualche parte all'interno di un metodo, questo stack aiuterà a identificare quel metodo.

printStackTrace()aiuta il programmatore a capire dove si è verificato il problema reale. printStacktrace()è un metodo della classe Throwabledi java.langpacchetto. Stampa diverse righe nella console di output. La prima riga è composta da diverse stringhe. Contiene il nome della sottoclasse Throwable e le informazioni sul pacchetto. Dalla seconda riga in poi, descrive la posizione / numero di riga dell'errore che inizia con at.

L'ultima riga descrive sempre la destinazione interessata dall'errore / eccezione. La penultima riga ci informa sulla riga successiva nello stack dove va il controllo dopo aver ottenuto il trasferimento dal numero di riga descritto nell'ultima riga. Gli errori / eccezioni rappresentano l'output sotto forma di stack, che sono stati inseriti nello stack tramite il fillInStackTrace()metodo di Throwableclasse, che a sua volta riempie i dettagli del trasferimento del controllo del programma nello stack di esecuzione. Le righe che iniziano con at, non sono altro che i valori dello stack di esecuzione. In questo modo il programmatore può capire dove si trova nel codice il vero problema.

Insieme al printStackTrace()metodo, è una buona idea usare e.getmessage().

printStackTrace()stampa le posizioni in cui si è verificata l'eccezione nel codice sorgente, consentendo così all'autore che ha scritto il programma di vedere cosa è andato storto. Ma poiché mostra problemi nel codice sorgente, gli utenti che possono avere o meno esperienza di codifica potrebbero non essere in grado di capire cosa è andato storto, quindi se il programma consente all'utente di inviare messaggi di errore agli autori, il gli utenti potrebbero non essere in grado di fornire dati validi su cosa è andato storto.

Dovresti considerare il Logger.getLogger()metodo, offre una migliore funzionalità di gestione delle eccezioni (registrazione) e inoltre printStackTrace()senza argomenti è considerato obsoleto e dovrebbe essere usato SOLO per scopi di debug, non per la visualizzazione dell'utente.

L' printStackTrace()aiuta il programmatore a capire dove si è verificato il problema reale. Il printStackTrace()metodo è un membro della classe Throwablenel java.langpacchetto.

printStackTraceè un metodo della Throwableclasse. Questo metodo visualizza un messaggio di errore nella console; dove stiamo ottenendo l'eccezione nel codice sorgente. Questi metodi possono essere utilizzati con il blocco catch e descrivono:

1. Nome dell'eccezione.
2. Descrizione dell'eccezione.
3. Posizione dell'eccezione nel codice sorgente.

I tre metodi che descrivono l'eccezione sulla console (in cui printStackTrace è uno di loro) sono:

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

Esempio:

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 () aiuta il programmatore a capire dove si è verificato il problema reale. Aiuta a rintracciare l'eccezione. è il metodo printStackTrace () della classe Throwable ereditato da ogni classe di eccezione. Questo metodo stampa lo stesso messaggio di e object e anche il numero di riga in cui si è verificata l'eccezione.

Quello che segue è un altro esempio di stack di stampa dell'eccezione in 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: questa è una nuova eccezione in Java ... in ClassName.methodName (fileName: 5)

Qual è l'uso del metodo e.printStackTrace () in Java?

Bene, lo scopo dell'utilizzo di questo metodo e.printStackTrace();è vedere cosa è esattamente sbagliato.

Ad esempio, vogliamo gestire un'eccezione. Diamo uno sguardo al seguente esempio.

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();
    }
  }
}

Ho usato il metodo e.printStackTrace();per mostrare esattamente cosa non va.

Nell'output possiamo vedere il seguente risultato.

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() dice su quale riga stai ricevendo un errore qualsiasi perché stai ricevendo un errore.

Esempio:

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