Thread: Better way of using e.printStackTrace()?

No! This is a very bad idea to do. If you want to propagate the exception up the stack, re-throw the original exception.

This will maintain the original stack trace, and doesn't add any extra false information which would throw someone debugging the problem off the real problem.

Here's the output if you wrap and throw a RuntimeException:

public class Test
{
	public static void fail_open(String path, boolean is_url) throws FileNotFoundException, MalformedURLException
	{
		try
		{
			if(is_url)
			{
				throw new MalformedURLException(path);
			}
			else
			{
				throw new FileNotFoundException(path);
			}
		}
		catch(FileNotFoundException e)
		{
			throw e;
		}
		catch(MalformedURLException e)
		{
			throw e;
		}
	}
 
	public static void main(String[] args) throws Exception // bad practice to throw in main, doubly bad because it's the generic Exception!
	{
		fail_open("blah.txt", false);
	}
}

The "proper" default behavior is:

 

Exception in thread "main" java.io.FileNotFoundException: blah.txt

	at Test.fail_open(Test.java:23)

	at Test.main(Test.java:40)

And the appropriate message if we wrapped and re-threw a RuntimeException:

 

Exception in thread "main" java.lang.RuntimeException: java.io.FileNotFoundException: blah.txt

	at Test.fail_open(Test.java:28)

	at Test.main(Test.java:40)

Caused by: java.io.FileNotFoundException: blah.txt

	at Test.fail_open(Test.java:23)

	... 1 more

Notice that all of the line numbers and stack trace of the RuntimeException point to where I re-threw the exception. The print stack trace method for RuntimeExceptions is somewhat smart that it will print a partial stack trace for the wrapped Throwable object, but you don't get the full trace displayed by default.

There's also have no way to catch different type of exceptions and handle them separately if we wrap it into a generic RuntimeException.

	public static void main(String[] args) throws Exception
	{
		try
		{
			fail_open("blah.txt", false);
		}
		catch(FileNotFoundException e)
		{
			System.out.println("bad file path");
		}
		catch(MalformedURLException e)
		{
			System.out.println("bad url");
		}
		try
		{
			fail_open("google.com", true);
		}
		catch(FileNotFoundException e)
		{
			System.out.println("bad file path");
		}
		catch(MalformedURLException e)
		{
			System.out.println("bad url");
		}
	}

This just won't work if you wrap your exceptions in a RuntimeException.

Personally I'm not a big fan of the way checked/unchecked exceptions work in Java, but it's a limitation we have to deal with. Trying to get around this by wrapping everything in a RuntimeException is just using a bad idea to try and "fix" a questionable design.