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

        Overriding methods should do more than simply call the same method in the super class

        intentionality - clear
        maintainability
        Code Smell
        • redundant
        • clumsy

        Why is this an issue?

        Overriding a method just to call the same method from the super class without performing any other actions is useless and misleading. The only time this is justified is in final overriding methods, where the effect is to lock in the parent class behavior. This rule ignores such overrides of equals, hashCode and toString.

        Noncompliant code example

        public void doSomething() {
          super.doSomething();
        }
        
        @Override
        public boolean isLegal(Action action) {
          return super.isLegal(action);
        }
        

        Compliant solution

        @Override
        public boolean isLegal(Action action) {         // Compliant - not simply forwarding the call
          return super.isLegal(new Action(/* ... */));
        }
        
        @Id
        @Override
        public int getId() {                            // Compliant - there is annotation different from @Override
          return super.getId();
        }
        
          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