向“ throws”添加未使用的异常

Question

Why does the Java compiler allow exceptions to be added via throws even when they're not possibly able to be thrown?

example:

private static void foo() throws java.io.FileNotFoundException {
    System.out.println("no possible FileNotFoundException here");
}

The above code compiles just fine, but it's not possible for a FileNotFoundException to be thrown.

Answer 1

I would suggest maintenance: because you might want to change that method later to add an operation that could throw a FileNotFoundException , and you want to force all callers of this method to know what to do if that method should be changed to throw FileNotFoundException in the future.

Another manifestation of the issue is that a subclass may override this method and throw the exception, and this cannot be determined by compiling the superclass alone.

Answer 2

Because the compiler isn't smart enough to find out every exception? It sounds quite logical that Java can't know the possible outcomes for all algorithms. Just like a programming language can never prove a mathematical exception, it can only execute mathematics.

This means that an obvious mathematical "infinite loop", isn't always obvious to the programming language. I think that for such reasoning, the compiler doesn't bother looking at what will be executed.

If the compiler would have to pre-check for all exceptions the coder writes, it might spend "days" checking the code. All in all it just seems better to have the programmer responsible for the exceptions. Either way, it doesn't hurt.

Answer 3

Checked exceptions are validated by the compiler only in the try { } block, method bodies are not validated. There are multiple reasons, the complexity of such check being one, the fact that a child class can override the method and decide to throw the exception is a second.

Answer 4

In Netbeans 7.3.1, this would show up as an "unreported exception" and it will warn you that it must be caught or declared. So it would be an error. It depends on your tool.