For a number of years now I have been unable to get a decent answer to the following question: why are some developers so against checked exceptions? I have had numerous conversations, read things on blogs, read what Bruce Eckel had to say (the first person I saw speak out against them).
I am currently writing some new code and paying very careful attention to how I deal with exceptions. I am trying to see the point of view of the "we don't like checked exceptions" crowd and I still cannot see it.
Every conversation I have ends with the same question going unanswered... let me set it up:
In general (from how Java was designed),
Erroris for things that should never be caught (VM has a peanut allergy and someone dropped a jar of peanuts on it)
RuntimeExceptionis for things that the programmer did wrong (programmer walked off the end of an array)
RuntimeException) is for things that are out of the programmer's control (disk fills up while writing to the file system, file handle limit for the process has been reached and you cannot open any more files)
Throwableis simply the parent of all of the exception types.
A common argument I hear is that if an exception happens then all the developer is going to do is exit the program.
Another common argument I hear is that checked exceptions make it harder to refactor code.
For the "all I am going to do is exit" argument I say that even if you are exiting you need to display a reasonable error message. If you are just punting on handling errors then your users won't be overly happy when the program exits without a clear indication of why.
For the "it makes it hard to refactor" crowd, that indicates that the proper level of abstraction wasn't chosen. Rather than declare a method throws an
IOException should be transformed into an exception that is more suited for what is going on.
I don't have an issue with wrapping Main with
catch(Exception) (or in some cases
catch(Throwable) to ensure that the program can exit gracefully - but I always catch the specific exceptions I need to. Doing that allows me to, at the very least, display an appropriate error message.
The question that people never reply to is this:
If you throw
RuntimeExceptionsubclasses instead of
Exceptionsubclasses then how do you know what you are supposed to catch?
If the answer is catch
Exception then you are also dealing with programmer errors the same way as system exceptions. That seems wrong to me.
If you catch
Throwable then you are treating system exceptions and VM errors (and the like) the same way. That seems wrong to me.
If the answer is that you catch only the exceptions you know are thrown then how do you know what ones are thrown? What happens when programmer X throws a new exception and forgot to catch it? That seems very dangerous to me.
I would say that a program that displays a stack trace is wrong. Do people who don't like checked exceptions not feel that way?
So, if you don't like checked exceptions can you explain why not AND answer the question that doesn't get answered please?
I am not looking for advice on when to use either model, what I am looking for is why people extend from
RuntimeException because they don't like extending from
Exception and/or why they catch an exception and then rethrow a
RuntimeException rather than add throws to their method. I want to understand the motivation for disliking checked exceptions.