Rethrowing exceptions in Java

Question

In C#, I can use the throw; statement to rethrow an exception while preserving the stack trace:

try
{
   ...
}
catch (Exception e)
{
   if (e is FooException)
     throw;
}

Is there something like this in Java (that doesn't lose the original stack trace)?

Answer 1

In Java is almost the same:

try
{
   ...
}
catch (Exception e)
{
   if (e instanceof FooException)
     throw e;
}

Answer 2

catch (WhateverException e) {
    throw e;
}

will simply rethrow the exception you've caught (obviously the surrounding method has to permit this via its signature etc.). The exception will maintain the original stack trace.

Answer 3

In Java, you just throw the exception you caught, so throw e rather than just throw. Java maintains the stack trace.

Answer 4

i would prefer

try
{
   ...
}
catch (FooException fe){
   throw fe;
}
catch (Exception e)
{
   ...
}

Answer 5

try 
{
  ...
}
catch (FooException e) 
{
  throw e;
}
catch (Exception e)
{
  ...
}

something like this

edit : too late :/

Answer 6

You can also wrap the exception in another one AND keep the original stack trace:

try
{
   ...
}
catch (Exception e)
{
     throw new YourOwnException(e);
}

Answer 7

I think the solutions will work, but I have a similar case, where I think this solutions produce quite ugly/bad maintainable code.

In my case. I want to call a logout-method, whenever an exception occurs and than rethrow the occured exception.

try
{
   ...
}
catch (Exception e)
{
   logout();
   throw e;
}

This changes the type of exceptions surrounding method throws to 'Exception', which is not as specific as before. [changes of the 'throw'-list of the method]

The other solution:

try 
{
  ...
}
catch (Foo1Exception e) 
{
  logout();
  throw e;
}
catch (Foo2Exception e)
{
  logout();
  throw e;
}
...

In this version I have to build a indentic catch-block for all Exception-subtypes the surrounding method may throw.

-> redundant code

-> each time I add a new exception-sub-type to the method, I have to add an extra catch-block. :-(

Exists a better way?