Thanks again for your comments!

> However, if you decide to return a value or throw a different exception
> within the finally block, that would override the exception or return value
> in the try block.

any return value or exception returned within a finally block overrides any return value or exception (in all 4 permutations) a try block would return.

The behavior you showed is reasonable. What happens is this:
When you throw an exception, the finally block is called. When the finally block finishes, the exception continues on normally, so the finally block is only for closing resources etc.
However, if you decide to return a value or throw a different exception within the finally block, that would override the exception or return value in the try block.
In your “aMethod”, your try block threw a typed exception, and was later overridden by the finally block because it returned a value. The reason the compiler didn’t request you to define the exception is because it identified that there is no chance for the exception to ever be actually thrown (the compiler is sometimes actually smart )
In your main method, the value was returned (“true”) and not the exception, and therefore the “not catched” response was given. If you remove the “return true” from your finally block, and place something else (some assignment or whatever) you’d see that (a) the compiler will request that you define the exception and (b) you’d get the “catched” response.

Hope I was clear in this explanation..

public class Test {

private static boolean aMethod() {
try {
throw new Exception();
} finally {
return true;
}
}

public static void main(String[] args) {
try {
aMethod();
System.err.println(“not catched!”);
} catch (Exception e) {
System.err.println(“catched!”);
}
}
}

To my old understanding (sorry for my ignorance) this snippet shouldn’t have compiled because an Exception is thrown without any catching nor declaration in the method signature.

1.) there’s no need for a catch if there’s a finally

But the other thing that astonished me is that the output is “not catched”. Looks like the exception is swallowed!

2.) deliberately omitting a catch is like writing an empty catch block…

or did I miss something?

It’s true though that the ones that are not need to be released by the exit hooks, though.

Actually, this is not always the case.
The finally block is only executed provided you don’t call something like System.exit() in the try block. If you run such a program, you will find that the finally block is not executed.

public class Test {
public static void main(String [] args) {
try {
System.out.println(“Message 1″);
System.exit(0);
} finally {
System.out.println(“This line is not executed!”);
}
}
}

Where do I get more information to this? The best I can get is the VM spec book, but it’s certainly outdated..