最终投掷之间的区别

Question

I am preparing for OCP exam and I'm using Enthuware . I got this question, what is the result of compiling and running the following code?

try {
    throw new IOException();
} catch(IOException e) {
    throw e;
} finally {
    throw new RuntimeException();
}

Obviously, the code does compile but it throws a RuntimeException and I totally understand why. I'm just curious why the following code doesn't compile:

try {
    throw new IOException();
} catch(IOException e) {
    throw e;
} finally {
    test();
}

Where test() function looks like:

static final void test() throws RuntimeException {
    throw new RuntimeException();
}

Even though I declared test function as final because I thought that it might the compiler is aware of overriding ...

Could someone please explain it to me?

Sorry for bad English!

-- Edit: Just wondering why down-vote?

Error message is compile error:

Unhandled exception type IOException

And the error message when I tried to compile it is:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: Unhandled exception type IOException

Answer 1

The first snippet compiles because the finally block runs before a value is returned or an exception thrown from the non- finally part of the method. The fact that you're throwing a RuntimeException means that you won't be throwing the IOException that you otherwise would. The compiler can work this out, and it therefore doesn't insist that you either declare or catch the IOException .

But the compiler only looks at one method at a time when it's performing this check. So the second snippet fails to compile, because the compiler doesn't check whether test() will always throw the RuntimeException . Instead, it assumes that test() might not throw the RuntimeException ; and if that were to happen, the IOException would be thrown. Therefore, the compiler insists that you either catch that IOException , or declare it in a throws clause.

Answer 2

In java Exception handling have concept Exception propagation.

An exception is first thrown from the top of the stack and if it is not caught, it drops down the call stack to the previous method, if not caught there, the exception again drops down to the previous method, and so on until they are caught or until they reach the very bottom of the call stack. This is called exception propagation.

Rule 1: By default, Unchecked Exceptions are forwarded in calling chain (propagated).

Rule 2: By default, Checked Exceptions are not forwarded in calling chain (propagated).

try {
    throw new IOException();
} catch(IOException e) {
    throw e;
} finally {
    throw new RuntimeException();
}

In above code snippet it's the throwing of the RuntimeException that prevents the throwing of the IOException.

try {
    throw new IOException();
} catch(IOException e) {
    throw e;
} finally {
    test();
}
static final void test() throws RuntimeException {
    throw new RuntimeException();
}

In above code snippet test() method throwing of the RuntimeException but not prevents the throwing of the IOException. As by Rule 2 by default compiler doesn't propagate the Checked Exceptions so for that you have to declare or handle the exception.

Lets take example if you replace IOException with RuntimeException then it will not give compiletime error because by Rule 1 by default unchecked Exceptions are forwarded in calling chain (propagated).

try {
    throw new RuntimeException();
} catch(RuntimeException e) {
    throw e;
} finally {
    test();
}
static final void test() throws RuntimeException{
    throw new RuntimeException();
}