CODEWITHSUNDEEP
javaexceptionstack-trace
trevalexandro
trevalexandro

Reputation: 213

Printing the stack trace vs the exception itself

quick question. Of course the stack trace gives way more information, but is it a bad practice to use the exception itself instead in some cases? Like just getting "null pointer exception" as opposed to this huge dump of stuff? If this doesn't make any sense, the two differences would be:

(Exception e)
{
  print e
}

AND

(Exception e)
{
  e.printStackTrace
}

Upvotes: 2

Views: 4521

Answers (3)

modal_dialog
modal_dialog

Reputation: 743

It depends on the context. Anything that will (or even might accidentally) be presented to the user should not include the stack trace. More than being confusing, you could leak potentially sensitive information.

In my code, I create custom exceptions that have a UserFriendlyMessage property. Friendly messages should be in very plain English. I even have a default catch-all friendly message "There was an unexpected problem. You can try again and if the problem continues contact support".

On the other hand, having the stack trace is invaluable for debugging. In my .NET apps, we go so far as to compile our release code in a special way such that the code is optimized but the symbols are still generated in a separate file. We do this for the sole purpose of ensuring full stack traces with line numbers.

So in summary, display only friendly messages but log (and if you are going to, alert) full stack traces + the friendly message.

Upvotes: 4

Eray Balkanli
Eray Balkanli

Reputation: 7960

The difference between them is that print e returns the type of exception and error message while printStackTrace returns the whole stacktrace of the exception. printStackTrace is more beneficial to be used while debugging.

Example:

print e:

java.lang.IndexOutOfBoundsException

e.printStackTrace():

java.lang.IndexOutOfBoundsException: Index: 8, Size: 0
    at java.util.ArrayList.RangeCheck(ArrayList.java:547)
    at java.util.ArrayList.get(ArrayList.java:322)
    at com.o2.business.util.Trial.test(CommonUtilsTest.java:866)

printStackTrace might be good for programmer, but it is not readable and user-friendly for end users. As far as I know, printStackTrace prints the results in the default Errorstream: your console. For better practices, you can check the link: http://www.onjava.com/pub/a/onjava/2003/11/19/exceptions.html

Upvotes: 3

Luiggi Mendoza
Luiggi Mendoza

Reputation: 85779

I will say use neither of them in production. You should handle exceptions in other ways, like logging the exception or saving the stacktrace somewhere to review it later and probably display a nice message to the user saying that the app or method failed.

But if you just ask about which of those approaches to use, I will say the latter is better because System.out.println(e) will call Throwable#toString that only provides the message of this exception and maybe you won't get the real cause of the problem.

Upvotes: 7

Related Questions