Exception handling is not the art of concealing every single error from the user and pretending like no error occurred.

– Well said. A well defined exception handling mechanism is a must for any software application.

In your app API ALWAYS wrap checked exceptions as RuntimeExceptions, and make sure that the “top level exception” handler logs and can return the original exception in its, getCause() method.

Swallowing exceptions is definitely a chicken shit response to not knowing how to throw them up higher, and deal with them at the user level.

Try
{
…
…
}
Catch (Exception ex)
{
//empty
}

the reason he gives is, that it shows exception when he’s debugging what ignores in runtime. this is lamest of all excuses to ignore exceptions i have ever heard.

switch ( foo ) {
case BAR: handleBar(); break;
case BAZ: handleBaz(); break;
…
default: /* can’t happen */
}

There are times when one doesn’t *care* if some code throws an exception, but this is normally a tiny, tiny fraction of the time. The advice to print the stack trace to a log file (or even stderr) is an excellent policy.

The rest of the time, we presumably care, but either don’t know what to do about an exception, or our API doesn’t allow for checked exceptions. Wrapping that checked exception is better than ignoring it:

try {
someObject.mightThrowCheckedException();
} catch (SomeCheckedException scx) {
throw new RuntimeException( scx);
}

And if it truly is a “Can’t Happen”, why, an error is called for:

try {
someObject.saysItThrowsCheckedExceptionButItLies();
} catch (LyingCheckedException lcx) {
InternalError ie = new InternalError(
“Programmer Assumption Violation” );
ie.initCause( lcx );
throw ie;
}

Or better yet:

public class PAVError extends InternalError {
public PAVError( Throwable t ) {
super(“Programmer Assumption Violation”);
initCause( t );
}
…
}

It would be nice if the difference between a checked and an unchecked exception were in how the exception is thrown, rather than the ancestor of the exception.

Generally I’m a bit mixed about checked exceptions but i still believe it goes back to the culture issue. Java enforces the handling, but it’s still up to the developer to do something meaningful with those catch blocks.