Qual é o uso do método printStackTrace () em Java?

Estou passando por um programa de soquete. Nele, printStackTraceé chamado no IOExceptionobjeto no bloco catch.
O que printStackTrace()realmente faz?

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

Não estou ciente de seu propósito. Para que isso é usado?

É um método em Exceptioninstâncias que imprime o rastreamento de pilha da instância emSystem.err .

É uma ferramenta muito simples, mas muito útil para diagnosticar exceções. Ele informa o que aconteceu e onde isso aconteceu no código.

Aqui está um exemplo de como ele pode ser usado na prática:

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

Eu também estava curioso sobre isso, então juntei um pequeno código de amostra onde você pode ver o que ele está fazendo:

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

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

Ligando println(e):

java.lang.NullPointerException

Ligando e.printStackTrace():

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

Isso ajuda a rastrear a exceção. Por exemplo, você está escrevendo alguns métodos em seu programa e um dos seus métodos causa um bug. Então, o printstack o ajudará a identificar qual método causa o bug. Stack ajudará assim:

Primeiro seu método principal será chamado e inserido na pilha, então o segundo método será chamado e inserido na pilha na ordem LIFO e se ocorrer algum erro em algum lugar dentro de qualquer método, esta pilha ajudará a identificar esse método.

printStackTrace()ajuda o programador a entender onde o problema real ocorreu. printStacktrace()é um método da classe Throwablede java.langpacote. Ele imprime várias linhas no console de saída. A primeira linha consiste em várias strings. Ele contém o nome da subclasse Throwable e as informações do pacote. Da segunda linha em diante, descreve a posição do erro / número da linha começando com at.

A última linha sempre descreve o destino afetado pelo erro / exceção. A penúltima linha nos informa sobre a próxima linha na pilha para onde o controle vai após obter a transferência do número de linha descrito na última linha. Os erros / exceções representam a saída na forma de uma pilha, que foram alimentados na pilha porfillInStackTrace() método da Throwableclasse, que por sua vez preenche os detalhes de transferência do controle do programa na pilha de execução. As linhas que começam com at, nada mais são do que os valores da pilha de execução. Desta forma, o programador pode entender onde está o problema real no código.

Junto com o printStackTrace()método, é uma boa ideia usar e.getmessage().

printStackTrace()imprime os locais onde a exceção ocorreu no código-fonte, permitindo assim ao autor que escreveu o programa ver o que deu errado. Mas, como mostra problemas no código-fonte, o (s) usuário (s) que pode (m) ou não ter experiência em codificação podem não ser capazes de entender o que deu errado, portanto, se o programa permitir que o usuário envie mensagens de erro aos autores, o os usuários podem não ser capazes de fornecer dados confiáveis ​​sobre o que deu errado.

Você deve considerar o Logger.getLogger()método, ele oferece uma facilidade de tratamento de exceções (registro) melhor e, além disso, printStackTrace()sem argumentos é considerado obsoleto e deve ser usado SOMENTE para fins de depuração, não para exibição do usuário.

Isso printStackTrace()ajuda o programador a entender onde o problema real ocorreu. O printStackTrace()método é membro da classe Throwabledo java.langpacote.

printStackTraceé um método da Throwableclasse. Este método exibe mensagem de erro no console; onde estamos obtendo a exceção no código-fonte. Esses métodos podem ser usados ​​com catch block e descrevem:

1. Nome da exceção.
2. Descrição da exceção.
3. Localização da exceção no código-fonte.

Os três métodos que descrevem a exceção no console (em que printStackTrace é um deles) são:

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

Exemplo:

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 () ajuda o programador a entender onde o problema real ocorreu. Isso ajuda a rastrear a exceção. é o método printStackTrace () da classe Throwable herdado por cada classe de exceção. Este método imprime a mesma mensagem do objeto e também o número da linha onde ocorreu a exceção.

A seguir está um outro exemplo de pilha de impressão da Exceção em 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: esta é uma nova exceção em Java ... em ClassName.methodName (fileName: 5)

Qual é a utilidade do método e.printStackTrace () em Java?

Bem, o objetivo de usar esse método e.printStackTrace();é ver o que exatamente está errado.

Por exemplo, queremos tratar uma exceção. Vamos dar uma olhada no seguinte exemplo.

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

Usei o método e.printStackTrace();para mostrar exatamente o que está errado.

Na saída, podemos ver o seguinte resultado.

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() informa em qual linha você está obtendo erro, por que motivo está obtendo erro.

Exemplo:

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