An exception in a throws
declaration in Java is superfluous if it is:
* listed multiple times
* a subclass of another listed exception
* completely unnecessary because the declared exception type cannot actually be thrown
void foo() throws MyException, MyException {} // Noncompliant; should be listed once void bar() throws Throwable, Exception {} // Noncompliant; Exception is a subclass of Throwable
void foo() throws MyException {} void bar() throws Throwable {}
The rule will not raise any issue for exceptions that cannot be thrown from the method body:
* in overriding and implementation methods
* in interface default
methods
* in non-private methods that only throw
, have empty bodies, or a single return statement.
* in overridable methods (non-final, or not member of a final class, non-static, non-private), if the exception is documented with a proper JavaDoc
Also, the rule won't raise issues on RuntimeException
, or one of its descendants, because explicating runtime exceptions which could
be thrown can ultimately help the method's users, and can even be considered as good practice.
class A extends B { @Override void doSomething() throws IOException { compute(a); } public void foo() throws IOException {} public void qix() throws MyRuntimeException {} protected void bar() throws IOException { throw new UnsupportedOperationException("This method should be implemented in subclasses"); } Object foobar(String s) throws IOException { return null; } /** * @throws IOException Overriding classes may throw this exception if they print values into a file */ protected void print() throws IOException { // no issue, method is overridable and the exception has proper javadoc System.out.println("foo"); } }