Uploaded image for project: 'Rules Repository'
  1. Rules Repository
  2. RSPEC-1130

"throws" declarations should not be superfluous

    XMLWordPrintable

    Details

    • Default Severity:
      Minor
    • Impact:
      Low
    • Likelihood:
      Low
    • Default Quality Profiles:
      Sonar way
    • Legacy Key:
      RedundantThrowsDeclarationCheck
    • Covered Languages:
      Java
    • Remediation Function:
      Constant/Issue
    • Constant Cost:
      5min
    • Analysis Scope:
      Main Sources, Test Sources

      Description

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

        Attachments

          Issue Links

          1.
          Java RSPEC-4773 Language-Specification Active Unassigned

            Activity

              People

              Assignee:
              Unassigned Unassigned
              Reporter:
              fabrice.bellingard Fabrice Bellingard
              Votes:
              0 Vote for this issue
              Watchers:
              1 Start watching this issue

                Dates

                Created:
                Updated: