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

Noncompliant Code Example

void foo() throws MyException, MyException {}  // Noncompliant; should be listed once
void bar() throws Throwable, Exception {}  // Noncompliant; Exception is a subclass of Throwable

Compliant Solution

void foo() throws MyException {}
void bar() throws Throwable {}

Exceptions

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");
  }
}