Why try/catch around throwable?

Question

In trying to refactor some I code I attempted to throw the exception in the catch clause like so -

try {
....
}
catch(Exception exception){
.....
throw exception
}

However when I attempted to throw the exception on line "throw exception" the compiler complained with a message that I needed to surround my throw clause in a new try/catch like so -

try
{
  ....
}
catch (Exception exception)
{
  .....
  try
  {
    throw exception
  }
  catch (Exception e2)
  {
     ...
  }
}

Why does the compiler require this and what use does it provide ?

Thanks

Thanks for all answers, the code is within the run method of a thread so I dont think I can throw the exception ? — blue-sky, May 12 '11 at 22:41
possible duplicate of [Throw error to calling method!](http://stackoverflow.com/questions/5976764/throw-error-to-calling-method) — McDowell, May 12 '11 at 22:50
I dont't think so but maybe im wrong, what I really want to know is why do I need to surround "throw exception" with a try catch. Surely an exception cannot be thrown while throwing an exception ? try { throw exception } catch (Exception e2) { ... } — blue-sky, May 12 '11 at 22:57

Stephen C · Answer 1 · 2011-05-12T22:32:55.303

3

The exception java.lang.Exception is a checked exception. This means that it must either be declared in the throws clause of the enclosing method or caught and handled withing the method body.

However, what you are doing in your "fixed" version is to catch the exception, rethrow it and then immediately catch it again. That doesn't make much sense.

Without seeing the real code, it is not clear what the real solution should be, but I expect that the problem is in the original try { ... } catch handler:

If possible, you should catch a more specific exception at that point, so that when you rethrow it, it is covered by the method's existing throws list.
Alternatively, you could wrap the exception in an unchecked exception and throw that instead.
As a last resort, you could change the signature of the method to include Exception in the throws list. But that's a really bad idea, because it just pushes the problem off to the caller ... and leaves the developer / reader in the position of not knowing what exceptions to expect.

edited May 12 '11 at 22:32

answered May 12 '11 at 22:23

Stephen C

698,415
94
811
1,216

I've seen valid cases for catching and rethrowing. those lines saying ... could be logging. Their could be logic on the exception itself etc. – Wes May 12 '11 at 22:24
@Wes - I'm talking about the "fixed" version of the code. I claim that the nested `try catch` makes no sense. You could remove the try block and inline the catch block and it would do the same thing faster with less lines of code. – Stephen C May 12 '11 at 22:36
Its okay I upvoted your answer before anyway. I just was a little confused as to what you were claiming. Note that it was before I saw your edit. – Wes May 12 '11 at 22:37

brian_d · Answer 2 · 2011-05-12T22:29:30.467

In your original code, nothing catches the thrown exception. I would imagine you either have to specify that your function throws an exception or have another try/catch block as the compiler suggests to catch it.

Instead of

public void yourFunction(){
  try {
    ....
  }
  catch(Exception exception){
    .....
    throw exception
  }
}

try

public void yourFunction() throws Exception{
  try {
    ....
  }
  catch(Exception exception){
    .....
    throw exception
  } 
}

score 1 · Answer 3 · answered May 12 '11 at 22:26

In Java, there is a distinction between checked and unchecked exceptions. An unchecked exception can essentially be thrown at any place in code and, if it's not caught somewhere, it will propagate up to the entry point of your application and then stop the process (usually with an error message and stack trace). A checked exception is different: The compiler won't let you just let it propagate, you need to either surround any code which might throw a checked exception with try-catch blocks (and "throw exception" is the simplest case if exception is an instance of a checked exception class) or you must mark the method which contains the call to code that might throw a checked exception with a "throws" declaration. If the desired behaviour is to throw an unchecked exception, then you'll need to wrap the exception in a RuntimeException. If the desired behaviour is to keep the exception checked, then you'll need to add a throws declaration to your current method.

Wes · Accepted Answer · 2011-05-12T22:40:44.173

My guess is that your trying to throw an exception sub class that isn't declared by the method as an exception type it can throw.

The following example works

package test.example;

public class ExceptionTest {

    public static void main(String[] args) throws Exception{
        try {
            int value = 1/0;
        } catch (Exception e) {
            System.out.println("woops the world is going to end");
            throw e;
        }

    }

}

However this example will give an error.

package test.example;

public class ExceptionTest {

    public static void main(String[] args) throws RuntimeException{
        try {
            int value = 1/0;
        } catch (Exception e) {
            System.out.println("woops the world is going to end");
            throw e;
        }

    }

}

Note in the second example I'm simply catching Exception not RuntimeException, it won't compile as I throw Exception which is an undeclared throws, even though I do declare RuntimeException.

Yes the exception is a RuntimeException but the compiler doesn't know that.

Just thought of a third working example to show you. This one also works because your throwing the same type as you declare. (note the only change is the catch block)

package test.example;

public class ExceptionTest {

    public static void main(String[] args) throws RuntimeException{
        try {
            int value = 1/0;
        } catch (RuntimeException e) {
            System.out.println("woops the world is going to end");
            throw e;
        }

    }

}

You need to understand the differences between all three of these answers

Why try/catch around throwable?

4 Answers4