SonarSource Rules
  • Products

    In-IDE

    Code Quality and Security in your IDE with SonarQube Ide

    IDE extension that lets you fix coding issues before they exist!

    Discover SonarQube for IDE

    SaaS

    Code Quality and Security in the cloud with SonarQube Cloud

    Setup is effortless and analysis is automatic for most languages

    Discover SonarQube Cloud

    Self-Hosted

    Code Quality and Security Self-Hosted with SonarQube Server

    Fast, accurate analysis; enterprise scalability

    Discover SonarQube Server
  • SecretsSecrets
  • ABAPABAP
  • AnsibleAnsible
  • ApexApex
  • AzureResourceManagerAzureResourceManager
  • CC
  • C#C#
  • C++C++
  • CloudFormationCloudFormation
  • COBOLCOBOL
  • CSSCSS
  • DartDart
  • DockerDocker
  • FlexFlex
  • GitHub ActionsGitHub Actions
  • GoGo
  • HTMLHTML
  • JavaJava
  • JavaScriptJavaScript
  • JSONJSON
  • JCLJCL
  • KotlinKotlin
  • KubernetesKubernetes
  • Objective CObjective C
  • PHPPHP
  • PL/IPL/I
  • PL/SQLPL/SQL
  • PythonPython
  • RPGRPG
  • RubyRuby
  • RustRust
  • ScalaScala
  • ShellShell
  • SwiftSwift
  • TerraformTerraform
  • TextText
  • TypeScriptTypeScript
  • T-SQLT-SQL
  • VB.NETVB.NET
  • VB6VB6
  • XMLXML
  • YAMLYAML
Java

Java static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your JAVA code

  • All rules 733
  • Vulnerability60
  • Bug175
  • Security Hotspot40
  • Code Smell458

  • Quick Fix 65
Filtered: 41 rules found
clumsy
    Impact
      Clean code attribute
        1. Call to Mockito method "verify", "when" or "given" should be simplified

           Code Smell
        2. Similar tests should be grouped in a single Parameterized test

           Code Smell
        3. An iteration on a Collection should be performed on the type handled by the Collection

           Code Smell
        4. "StandardCharsets" constants should be preferred

           Code Smell
        5. "Stream.collect()" calls should not be redundant

           Code Smell
        6. "Stream" call chains should be simplified when possible

           Code Smell
        7. Arrays should not be created for varargs parameters

           Code Smell
        8. Unit tests should throw exceptions

           Code Smell
        9. Jump statements should not be redundant

           Code Smell
        10. "Optional" should not be used for parameters

           Code Smell
        11. Default annotation parameter values should not be passed as arguments

           Code Smell
        12. ".isEmpty" should be used to test for the emptiness of StringBuffers/Builders

           Code Smell
        13. Arguments to "append" should not be concatenated

           Code Smell
        14. Arrays and lists should not be copied using loops

           Code Smell
        15. "catch" clauses should do more than rethrow

           Code Smell
        16. Synchronizing on a "Lock" object should be avoided

           Code Smell
        17. Classes with only "static" methods should not be instantiated

           Code Smell
        18. Redundant modifiers should not be used

           Code Smell
        19. The diamond operator ("<>") should be used

           Code Smell
        20. Switches should be used for sequences of simple "String" tests

           Code Smell
        21. Do not perform unnecessary mathematical operations

           Code Smell
        22. Unnecessary boxing and unboxing should be avoided

           Bug
        23. Catches should be combined

           Code Smell
        24. Methods of "Random" that return floating point values should not be used in random integer generation

           Code Smell
        25. String operations with predictable outcomes should be avoided

           Bug
        26. Classes should not be empty

           Code Smell
        27. Extensions and implementations should not be redundant

           Code Smell
        28. Redundant casts should not be used

           Code Smell
        29. "toString()" should never be called on a String object

           Code Smell
        30. Local variables should not be declared and then immediately returned or thrown

           Code Smell
        31. A "while" loop should be used instead of a "for" loop

           Code Smell
        32. Exception types should not be tested using "instanceof" in catch blocks

           Code Smell
        33. Overriding methods should do more than simply call the same method in the super class

           Code Smell
        34. Primitive wrappers should not be instantiated only for "toString" or "compareTo" calls

           Code Smell
        35. Case insensitive string comparisons should be made without intermediate upper or lower casing

           Code Smell
        36. "Collection.isEmpty()" should be used to test for emptiness

           Code Smell
        37. "String.valueOf()" should not be appended to a "String"

           Code Smell
        38. Exceptions in "throws" clauses should not be superfluous

           Code Smell
        39. Return of boolean expressions should not be wrapped into an "if-then-else" statement

           Code Smell
        40. Boolean literals should not be redundant

           Code Smell
        41. Mergeable "if" statements should be combined

           Code Smell

        Exceptions in "throws" clauses should not be superfluous

        intentionality - clear
        maintainability
        Code Smell
        Quick FixIDE quick fixes available with SonarQube for IDE
        • error-handling
        • unused
        • redundant
        • clumsy

        Why is this an issue?

        Superfluous exceptions within throws clauses have negative effects on the readability and maintainability of the code. An exception in a throws clause is superfluous if it is:

        • listed multiple times
        • a subclass of another listed exception
        • not actually thrown by any execution path of the method

        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
        void boo() throws IOException { // Noncompliant; IOException cannot be thrown
          System.out.println("Hi!");
        }
        

        Compliant solution

        void foo() throws MyException {}
        void bar() throws Throwable {}
        void boo() {
          System.out.println("Hi!");
        }
        

        Exceptions

        The rule will not raise any issue for exceptions that cannot be thrown from the method body:

        • in interface default methods
        • in overriding and implementating 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
        interface MyInterface {
          default void defaultMethod() throws IOException {
            System.out.println("Hi!");
          }
          void doSomething() throws IOException;
        }
        
        class A implements MyInterface {
          @Override
          void doSomething() throws IOException {
            System.out.println("Hi!");
          }
        
          public void emptyBody() throws IOException {}
        
          protected void singleThrowStatement() throws IOException {
            throw new UnsupportedOperationException("This method should be implemented in subclasses");
          }
        
          Object singleReturnStatement() throws IOException {
            return null;
          }
        
          /**
           * @throws IOException Overriding classes may throw this exception if they print values into a file
           */
          protected void overridable() throws IOException { // no issue, method is overridable and the exception has proper javadoc
            System.out.println("foo");
          }
        }
        

        Also, the rule will not raise issues on RuntimeException, or one of its sub-classes, because documenting runtime exceptions which could be thrown can ultimately help users of the method understand its behavior.

        class B {
          int possibleDivisionByZero(int a, int b) throws ArithmeticException {
              return a / b;
          }
        }
        
          Available In:
        • SonarQube IdeCatch issues on the fly,
          in your IDE
        • SonarQube CloudDetect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories
        • SonarQube Community BuildAnalyze code in your
          on-premise CI
          Available Since
          9.1
        • SonarQube ServerAnalyze code in your
          on-premise CI
          Developer Edition
          Available Since
          9.1

        © 2008-2025 SonarSource SA. All rights reserved.

        Privacy Policy | Cookie Policy | Terms of Use