Throwing generic exceptions such as Error, RuntimeException, Throwable, and Exception will have
a negative impact on any code trying to catch these exceptions.
From a consumer perspective, it is generally a best practice to only catch exceptions you intend to handle. Other exceptions should ideally be let
to propagate up the stack trace so that they can be dealt with appropriately. When a generic exception is thrown, it forces consumers to catch
exceptions they do not intend to handle, which they then have to re-throw.
Besides, when working with a generic type of exception, the only way to distinguish between multiple exceptions is to check their message, which is
error-prone and difficult to maintain. Legitimate exceptions may be unintentionally silenced and errors may be hidden.
For instance, when a Throwable is caught and not re-thrown, it may mask errors such as OutOfMemoryError and prevent the
program from terminating gracefully.
When throwing an exception, it is therefore recommended to throw the most specific exception possible so that it can be handled intentionally by
consumers.
Exceptions
Generic exceptions in the signatures of overriding methods are ignored, because an overriding method has to follow the signature of the throw
declaration in the superclass. The issue will be raised on superclass declaration of the method (or won’t be raised at all if superclass is not part
of the analysis).
@Override
public void myMethod() throws Exception {...}
Generic exceptions are also ignored in the signatures of methods that make calls to methods that throw generic exceptions.
public void myOtherMethod() throws Exception {
doTheThing(); // this method throws Exception
}
