Re: Java 7 features
pkriens wrote:
I think Java itself has promoted this API design, including the fact
that exceptions are part of the signature. Adding a new throw clause
is signature incompatible.
Exceptions are part of the contract the method offers, so
it is not that unlogical to put it in the code instead of
the documentation.
Let us take a very common case. I create a function that does some
wonderful calculation lets say doSomethingWonderful(), using some
configuration data, historical data, and a cache. Now my cache throws
an IOException because the disk is bad or my JDBC gives me an
exception because the database is bad, or I get some configuration
exception because the user messed up.
I am an expert in doSomethingWonderful(), how can I fix any of those
things? I just have to clean up when they happen and pass them upwards
so the top caller can do something useful with this failure like
telling the user or retrying. However, do you want me to list
SQLException, IOException, and ConfigurationException all to my
method? This is silly isnt it, because when I change my implementation
and get another exception, suddenly my signature changes without
anybody caring. In the end just throw Exception making the whole thing
silly. And in fact, over time almost all my implementation methods
list the useless throws Exception clause :-(
True.
But that problem is not due to checked exceptions but due to
bad OO design.
The exceptions your component can not handle should be encapsulated
in a component specific exception, so your component does not expose
implementation specifics.
Exceptions are failures, they should just -not- happen in runtime. If
they happen, we have a program error or an environmental error. Either
case, we fail and the failure needs to be handled, but the code that
can handle the semantics of the failure is rare. Take IOException for
a disk error, if it could be fixed in some way, the reporter should
have done it, not me. I have no clue what to do with a disk error.
There are lots of exceptions that may be thrown at runtime without
faults in the code. Some of them is recoverable. And a few of them
must be recovered for.
Arne