hiifong/pmd
1
0
Fork 0
forked from phoedos/pmd
Code Pull Requests Activity
pmd/pmd_rules_java_design.html

3996 lines
190 KiB
HTML
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="description" content="Rules that help you discover design issues.">
<meta name="keywords" content=" Design, AbstractClassWithoutAnyMethod, AvoidCatchingGenericException, AvoidDeeplyNestedIfStmts, AvoidRethrowingException, AvoidThrowingNewInstanceOfSameException, AvoidThrowingNullPointerException, AvoidThrowingRawExceptionTypes, AvoidUncheckedExceptionsInSignatures, ClassWithOnlyPrivateConstructorsShouldBeFinal, CollapsibleIfStatements, CouplingBetweenObjects, CognitiveComplexity, CyclomaticComplexity, DataClass, DoNotExtendJavaLangError, ExceptionAsFlowControl, ExcessiveImports, ExcessiveParameterList, ExcessivePublicCount, FinalFieldCouldBeStatic, GodClass, ImmutableField, InvalidJavaBean, LawOfDemeter, LogicInversion, LoosePackageCoupling, NcssCount, NPathComplexity, SignatureDeclareThrowsException, SimplifiedTernary, SimplifyBooleanExpressions, SimplifyBooleanReturns, SimplifyConditional, SingularField, SwitchDensity, TooManyFields, TooManyMethods, UselessOverridingMethod, UseObjectForClearerAPI, UseUtilityClass, MutableStaticState">
<title>Design | PMD Source Code Analyzer</title>
<link rel="stylesheet" type="text/css" href="assets/fontawesome-free-5.15.4-web/css/all.min.css">
<link rel="stylesheet" type="text/css" href="assets/bootstrap-4.5.2-dist/css/bootstrap.min.css">
<link rel="stylesheet" type="text/css" href="css/syntax.css">
<link rel="stylesheet" type="text/css" href="css/modern-business.css">
<link rel="stylesheet" type="text/css" href="css/customstyles.css">
<link rel="stylesheet" type="text/css" href="css/theme-green.css">
<link rel="stylesheet" type="text/css" href="css/pmd-customstyles.css">
<link rel="shortcut icon" href="images/logo/favicon.ico" type="image/x-icon">
<link rel="icon" href="images/logo/favicon.ico" type="image/x-icon">
<link rel="alternate" type="application/rss+xml" title="" href="feed.xml">
</head>
<body>
<!-- Content is offset by the height of the topnav bar. -->
<!-- There's already a padding-top rule in modern-business.css, but it apparently doesn't work on Firefox 60 and Chrome 67 -->
<div id="topbar-content-offset">
<!-- Navigation -->
<nav class="navbar navbar-expand-lg fixed-top navbar-dark">
<div class="container topnavlinks">
<a class="navbar-brand fas fa-home fa-lg" href="index.html">&nbsp;<span class="projectTitle"> PMD Source Code Analyzer Project</span></a>
<button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbarSupportedContent">
<ul class="navbar-nav mr-auto mt-2 mt-lg-0"></ul>
<ul class="navbar-nav">
<!-- toggle sidebar button -->
<li class="nav-item"><a id="tg-sb-link" class="nav-link" href="#"><i id="tg-sb-icon" class="fas fa-toggle-on"></i> Nav</a></li>
<!-- entries without drop-downs appear here -->
<li class="nav-item"><a class="nav-link" href="https://github.com/pmd/pmd/releases/latest" target="_blank">Download</a></li>
<li class="nav-item"><a class="nav-link" href="https://github.com/pmd/pmd" target="_blank">Fork us on github</a></li>
<!-- entries with drop-downs appear here -->
<!-- conditional logic to control which topnav appears for the audience defined in the configuration file.-->
</ul>
<form class="form-inline my-2 my-lg-0">
<input class="form-control mr-sm-2" type="search" placeholder="search..." id="search-input">
<ul id="results-container"></ul>
</form>
</div>
</div>
</nav>
<!-- Page Content -->
<div class="container-toc-wrapper">
<div class="container">
<div class="col-lg-12">&nbsp;</div>
<!-- Content Row -->
<div class="row">
<!-- Sidebar Column -->
<div class="col-md-3" id="tg-sb-sidebar">
<ul id="mysidebar" class="nav">
<li class="sidebarTitle">PMD 7.4.0-SNAPSHOT</li>
<div class="sidebarTitleDate">Release date: 26-July-2024</div>
<li>
<a href="#">About</a>
<ul>
<li><a href="index.html">Home</a></li>
<li><a href="pmd_release_notes.html">Release notes</a></li>
<li><a href="pmd_release_notes_pmd7.html">Release notes (PMD 7)</a></li>
<li><a href="pmd_about_help.html">Getting help</a></li>
<li><a href="pmd_about_release_policies.html">Release policies</a></li>
<li><a href="pmd_about_support_lifecycle.html">Support lifecycle</a></li>
</ul>
</li>
<li>
<a href="#">User Documentation</a>
<ul>
<li><a href="pmd_userdocs_migrating_to_pmd7.html">Migration Guide for PMD 7</a></li>
<li><a href="pmd_userdocs_installation.html">Installation and basic CLI usage</a></li>
<li><a href="pmd_userdocs_making_rulesets.html">Making rulesets</a></li>
<li><a href="pmd_userdocs_configuring_rules.html">Configuring rules</a></li>
<li><a href="pmd_userdocs_best_practices.html">Best practices</a></li>
<li><a href="pmd_userdocs_suppressing_warnings.html">Suppressing warnings</a></li>
<li><a href="pmd_userdocs_incremental_analysis.html">Incremental analysis</a></li>
<li><a href="pmd_userdocs_cli_reference.html">PMD CLI reference</a></li>
<li><a href="pmd_userdocs_report_formats.html">PMD Report formats</a></li>
<li><a href="pmd_userdocs_3rdpartyrulesets.html">3rd party rulesets</a></li>
<li class="subfolders">
<a href="#">CPD reference</a>
<ul>
<li><a href="pmd_userdocs_cpd.html">Copy-paste detection</a></li>
<li><a href="pmd_userdocs_cpd_report_formats.html">CPD Report formats</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Extending PMD</a>
<ul>
<li><a href="pmd_userdocs_extending_writing_rules_intro.html">Introduction to writing rules</a></li>
<li><a href="pmd_userdocs_extending_your_first_rule.html">Your first rule</a></li>
<li><a href="pmd_userdocs_extending_writing_xpath_rules.html">XPath rules</a></li>
<li><a href="pmd_userdocs_extending_writing_java_rules.html">Java rules</a></li>
<li><a href="pmd_userdocs_extending_designer_reference.html">Rule designer reference</a></li>
<li><a href="pmd_userdocs_extending_defining_properties.html">Defining rule properties</a></li>
<li><a href="pmd_userdocs_extending_rule_guidelines.html">Rule guidelines</a></li>
<li><a href="pmd_userdocs_extending_testing.html">Testing your rules</a></li>
<li><a href="pmd_userdocs_extending_ast_dump.html">Creating (XML) dump of the AST</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Tools / Integrations</a>
<ul>
<li><a href="pmd_userdocs_tools_maven.html">Maven PMD Plugin</a></li>
<li><a href="pmd_userdocs_tools_gradle.html">Gradle</a></li>
<li><a href="pmd_userdocs_tools_ant.html">Ant</a></li>
<li><a href="pmd_userdocs_tools_java_api.html">PMD Java API</a></li>
<li><a href="pmd_userdocs_tools_bld.html">bld PMD Extension</a></li>
<li><a href="pmd_userdocs_tools_ci.html">CI integrations</a></li>
<li><a href="pmd_userdocs_tools.html">Other Tools / Integrations</a></li>
</ul>
</li>
</ul>
</li>
<li>
<a href="#">Rule Reference</a>
<ul>
<li class="subfolders">
<a href="#">Apex Rules</a>
<ul>
<li><a href="pmd_rules_apex.html">Index</a></li>
<li><a href="pmd_rules_apex_bestpractices.html">Best Practices</a></li>
<li><a href="pmd_rules_apex_codestyle.html">Code Style</a></li>
<li><a href="pmd_rules_apex_design.html">Design</a></li>
<li><a href="pmd_rules_apex_documentation.html">Documentation</a></li>
<li><a href="pmd_rules_apex_errorprone.html">Error Prone</a></li>
<li><a href="pmd_rules_apex_performance.html">Performance</a></li>
<li><a href="pmd_rules_apex_security.html">Security</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">HTML Rules</a>
<ul>
<li><a href="pmd_rules_html.html">Index</a></li>
<li><a href="pmd_rules_html_bestpractices.html">Best Practices</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Java Rules</a>
<ul>
<li><a href="pmd_rules_java.html">Index</a></li>
<li><a href="pmd_rules_java_bestpractices.html">Best Practices</a></li>
<li><a href="pmd_rules_java_codestyle.html">Code Style</a></li>
<li class="active"><a href="pmd_rules_java_design.html">Design</a></li>
<li><a href="pmd_rules_java_documentation.html">Documentation</a></li>
<li><a href="pmd_rules_java_errorprone.html">Error Prone</a></li>
<li><a href="pmd_rules_java_multithreading.html">Multithreading</a></li>
<li><a href="pmd_rules_java_performance.html">Performance</a></li>
<li><a href="pmd_rules_java_security.html">Security</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Java Server Pages Rules</a>
<ul>
<li><a href="pmd_rules_jsp.html">Index</a></li>
<li><a href="pmd_rules_jsp_bestpractices.html">Best Practices</a></li>
<li><a href="pmd_rules_jsp_codestyle.html">Code Style</a></li>
<li><a href="pmd_rules_jsp_design.html">Design</a></li>
<li><a href="pmd_rules_jsp_errorprone.html">Error Prone</a></li>
<li><a href="pmd_rules_jsp_security.html">Security</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">JavaScript Rules</a>
<ul>
<li><a href="pmd_rules_ecmascript.html">Index</a></li>
<li><a href="pmd_rules_ecmascript_bestpractices.html">Best Practices</a></li>
<li><a href="pmd_rules_ecmascript_codestyle.html">Code Style</a></li>
<li><a href="pmd_rules_ecmascript_errorprone.html">Error Prone</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Kotlin Rules</a>
<ul>
<li><a href="pmd_rules_kotlin.html">Index</a></li>
<li><a href="pmd_rules_kotlin_bestpractices.html">Best Practices</a></li>
<li><a href="pmd_rules_kotlin_errorprone.html">Error Prone</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Maven POM Rules</a>
<ul>
<li><a href="pmd_rules_pom.html">Index</a></li>
<li><a href="pmd_rules_pom_errorprone.html">Error Prone</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Modelica Rules</a>
<ul>
<li><a href="pmd_rules_modelica.html">Index</a></li>
<li><a href="pmd_rules_modelica_bestpractices.html">Best Practices</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">PLSQL Rules</a>
<ul>
<li><a href="pmd_rules_plsql.html">Index</a></li>
<li><a href="pmd_rules_plsql_bestpractices.html">Best Practices</a></li>
<li><a href="pmd_rules_plsql_codestyle.html">Code Style</a></li>
<li><a href="pmd_rules_plsql_design.html">Design</a></li>
<li><a href="pmd_rules_plsql_errorprone.html">Error Prone</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Salesforce Visualforce Rules</a>
<ul>
<li><a href="pmd_rules_visualforce.html">Index</a></li>
<li><a href="pmd_rules_visualforce_security.html">Security</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Scala Rules</a>
<ul>
<li><a href="pmd_rules_scala.html">Index</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Swift Rules</a>
<ul>
<li><a href="pmd_rules_swift.html">Index</a></li>
<li><a href="pmd_rules_swift_bestpractices.html">Best Practices</a></li>
<li><a href="pmd_rules_swift_errorprone.html">Error Prone</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Velocity Template Language (VTL) Rules</a>
<ul>
<li><a href="pmd_rules_velocity.html">Index</a></li>
<li><a href="pmd_rules_velocity_bestpractices.html">Best Practices</a></li>
<li><a href="pmd_rules_velocity_design.html">Design</a></li>
<li><a href="pmd_rules_velocity_errorprone.html">Error Prone</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">WSDL Rules</a>
<ul>
<li><a href="pmd_rules_wsdl.html">Index</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">XML Rules</a>
<ul>
<li><a href="pmd_rules_xml.html">Index</a></li>
<li><a href="pmd_rules_xml_bestpractices.html">Best Practices</a></li>
<li><a href="pmd_rules_xml_errorprone.html">Error Prone</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">XSL Rules</a>
<ul>
<li><a href="pmd_rules_xsl.html">Index</a></li>
<li><a href="pmd_rules_xsl_codestyle.html">Code Style</a></li>
<li><a href="pmd_rules_xsl_performance.html">Performance</a></li>
</ul>
</li>
</ul>
</li>
<li>
<a href="#">Language-Specific Documentation</a>
<ul>
<li><a href="pmd_languages_index.html">Overview</a></li>
<li><a href="pmd_languages_configuration.html">Language configuration</a></li>
<li><a href="pmd_languages_apex.html">Apex</a></li>
<li><a href="pmd_languages_cpp.html">C/C++</a></li>
<li><a href="pmd_languages_cs.html">C#</a></li>
<li><a href="pmd_languages_coco.html">Coco</a></li>
<li><a href="pmd_languages_dart.html">Dart</a></li>
<li><a href="pmd_languages_fortran.html">Fortran</a></li>
<li><a href="pmd_languages_gherkin.html">Gherkin</a></li>
<li><a href="pmd_languages_go.html">Go</a></li>
<li><a href="pmd_languages_html.html">HTML</a></li>
<li><a href="pmd_languages_java.html">Java</a></li>
<li><a href="pmd_languages_js_ts.html">JavaScript / TypeScript</a></li>
<li><a href="pmd_languages_jsp.html">JSP</a></li>
<li><a href="pmd_languages_julia.html">Julia</a></li>
<li><a href="pmd_languages_kotlin.html">Kotlin</a></li>
<li><a href="pmd_languages_lua.html">Lua</a></li>
<li><a href="pmd_languages_matlab.html">Matlab</a></li>
<li><a href="pmd_languages_modelica.html">Modelica</a></li>
<li><a href="pmd_languages_objectivec.html">Objective-C</a></li>
<li><a href="pmd_languages_perl.html">Perl</a></li>
<li><a href="pmd_languages_php.html">PHP</a></li>
<li><a href="pmd_languages_plsql.html">PLSQL</a></li>
<li><a href="pmd_languages_python.html">Python</a></li>
<li><a href="pmd_languages_ruby.html">Ruby</a></li>
<li><a href="pmd_languages_scala.html">Scala</a></li>
<li><a href="pmd_languages_swift.html">Swift</a></li>
<li><a href="pmd_languages_tsql.html">T-SQL</a></li>
<li><a href="pmd_languages_visualforce.html">Visualforce</a></li>
<li><a href="pmd_languages_velocity.html">Velocity Template Language (VTL)</a></li>
<li><a href="pmd_languages_xml.html">XML and XML dialects</a></li>
</ul>
</li>
<li>
<a href="#">Developer Documentation</a>
<ul>
<li><a href="pmd_devdocs_development.html">Developer resources</a></li>
<li><a href="pmd_devdocs_building.html">Building PMD from source</a></li>
<li><a href="https://github.com/pmd/pmd/blob/master/CONTRIBUTING.md" target="_blank">Contributing</a></li>
<li><a href="pmd_devdocs_writing_documentation.html">Writing documentation</a></li>
<li><a href="pmd_devdocs_roadmap.html">Roadmap</a></li>
<li><a href="pmd_devdocs_how_pmd_works.html">How PMD works</a></li>
<li><a href="pmd_devdocs_pmdtester.html">Pmdtester</a></li>
<li><a href="pmd_devdocs_rule_deprecation_policy.html">Rule Deprecation Policy</a></li>
<li class="subfolders">
<a href="#">Major contributions</a>
<ul>
<li><a href="pmd_devdocs_major_rule_guidelines.html">Rule Guidelines</a></li>
<li><a href="pmd_devdocs_major_adding_new_language_javacc.html">Adding a new language (JavaCC)</a></li>
<li><a href="pmd_devdocs_major_adding_new_language_antlr.html">Adding a new language (ANTLR)</a></li>
<li><a href="pmd_devdocs_major_adding_new_cpd_language.html">Adding a new CPD language</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">Experimental features</a>
<ul>
<li><a href="tag_experimental.html">List of experimental Features</a></li>
</ul>
</li>
</ul>
</li>
<li>
<a href="#">Project documentation</a>
<ul>
<li class="subfolders">
<a href="#">Trivia about PMD</a>
<ul>
<li><a href="pmd_projectdocs_trivia_news.html">PMD in the press</a></li>
<li><a href="pmd_projectdocs_trivia_products.html">Products & books related to PMD</a></li>
<li><a href="pmd_projectdocs_trivia_similarprojects.html">Similar projects</a></li>
<li><a href="pmd_projectdocs_trivia_meaning.html">What does 'PMD' mean?</a></li>
</ul>
</li>
<li><a href="pmd_projectdocs_logo.html">Logo</a></li>
<li><a href="pmd_projectdocs_faq.html">FAQ</a></li>
<li><a href="license.html">License</a></li>
<li><a href="pmd_projectdocs_credits.html">Credits</a></li>
<li><a href="pmd_release_notes_old.html">Old release notes</a></li>
<li><a href="pmd_projectdocs_decisions.html">Decisions</a></li>
<li class="subfolders">
<a href="#">Project management</a>
<ul>
<li><a href="pmd_projectdocs_committers_infrastructure.html">Infrastructure</a></li>
<li><a href="pmd_projectdocs_committers_releasing.html">Release process</a></li>
<li><a href="pmd_projectdocs_committers_merging_pull_requests.html">Merging pull requests</a></li>
<li><a href="pmd_projectdocs_committers_main_landing_page.html">Main Landing page</a></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<!-- Content Column -->
<div class="col-md-9" id="tg-sb-content">
<header>
<div class="row">
<div class="col-lg-12">
<a href="./" role="button"
><i class="fa fa-home fa-lg"></i
></a>
» Design
<a
target="_blank"
href="https://github.com/pmd/pmd/blob/master/docs/../pmd-java/src/main/resources/category/java/design.xml"
class="float-right"
role="button"
><i class="fab fa-github fa-lg"></i> Edit on GitHub</a
>
</div>
</div>
<hr />
</header>
<div class="post-header">
<h1 class="post-title-main">Design</h1>
</div>
<div class="post-content" data-github-edit-url="https://github.com/pmd/pmd/blob/master/docs/../pmd-java/src/main/resources/category/java/design.xml">
<div class="summary">Rules that help you discover design issues.</div>
<details id="inline-toc-details">
<summary>Table of Contents</summary>
<div id="inline-toc"><!-- empty, move TOC here when screen size too small --></div>
</details>
<!-- DO NOT EDIT THIS FILE. This file is generated from file ../pmd-java/src/main/resources/category/java/design.xml. -->
<h2 id="abstractclasswithoutanymethod">AbstractClassWithoutAnyMethod</h2>
<p><strong>Since:</strong> PMD 4.2</p>
<p><strong>Priority:</strong> High (1)</p>
<p>If an abstract class does not provide any methods, it may be acting as a simple data container
that is not meant to be instantiated. In this case, it is probably better to use a private or
protected constructor in order to prevent instantiation than make the class misleadingly abstract.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">ClassDeclaration</span><span class="w">
</span><span class="p">[</span><span class="na">@Abstract</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nf">true</span><span class="p">()</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="na">@Interface</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nf">false</span><span class="p">()]</span><span class="w">
</span><span class="p">[</span><span class="nt">ClassBody</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="nt">ConstructorDeclaration</span><span class="w"> </span><span class="p">|</span><span class="w"> </span><span class="nt">MethodDeclaration</span><span class="p">)]]</span><span class="w">
</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="nn">pmd-java:</span><span class="nf">hasAnnotation</span><span class="p">(</span><span class="s1">'com.google.auto.value.AutoValue'</span><span class="p">)</span><span class="w">
</span><span class="ow">or</span><span class="w"> </span><span class="nn">pmd-java:</span><span class="nf">hasAnnotation</span><span class="p">(</span><span class="s1">'lombok.AllArgsConstructor'</span><span class="p">)</span><span class="w">
</span><span class="ow">or</span><span class="w"> </span><span class="nn">pmd-java:</span><span class="nf">hasAnnotation</span><span class="p">(</span><span class="s1">'lombok.NoArgsConstructor'</span><span class="p">)</span><span class="w">
</span><span class="ow">or</span><span class="w"> </span><span class="nn">pmd-java:</span><span class="nf">hasAnnotation</span><span class="p">(</span><span class="s1">'lombok.RequiredArgsConstructor'</span><span class="p">))</span><span class="w">
</span><span class="p">]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">abstract</span> <span class="kd">class</span> <span class="nc">Example</span> <span class="o">{</span>
<span class="nc">String</span> <span class="n">field</span><span class="o">;</span>
<span class="kt">int</span> <span class="n">otherField</span><span class="o">;</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/AbstractClassWithoutAnyMethod"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="avoidcatchinggenericexception">AvoidCatchingGenericException</h2>
<p><strong>Since:</strong> PMD 4.2.6</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">CatchParameter</span><span class="o">//</span><span class="nt">ClassType</span><span class="p">[</span><span class="w">
</span><span class="nn">pmd-java:</span><span class="nf">typeIsExactly</span><span class="p">(</span><span class="s1">'java.lang.NullPointerException'</span><span class="p">)</span><span class="w"> </span><span class="ow">or</span><span class="w">
</span><span class="nn">pmd-java:</span><span class="nf">typeIsExactly</span><span class="p">(</span><span class="s1">'java.lang.Exception'</span><span class="p">)</span><span class="w"> </span><span class="ow">or</span><span class="w">
</span><span class="nn">pmd-java:</span><span class="nf">typeIsExactly</span><span class="p">(</span><span class="s1">'java.lang.RuntimeException'</span><span class="p">)]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">package</span> <span class="nn">com.igate.primitive</span><span class="o">;</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">PrimitiveType</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">downCastPrimitiveType</span><span class="o">()</span> <span class="o">{</span>
<span class="k">try</span> <span class="o">{</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">" i ["</span> <span class="o">+</span> <span class="n">i</span> <span class="o">+</span> <span class="s">"]"</span><span class="o">);</span>
<span class="o">}</span> <span class="k">catch</span><span class="o">(</span><span class="nc">Exception</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
<span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
<span class="o">}</span> <span class="k">catch</span><span class="o">(</span><span class="nc">RuntimeException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
<span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
<span class="o">}</span> <span class="k">catch</span><span class="o">(</span><span class="nc">NullPointerException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
<span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/AvoidCatchingGenericException"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="avoiddeeplynestedifstmts">AvoidDeeplyNestedIfStmts</h2>
<p><strong>Since:</strong> PMD 1.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Avoid creating deeply nested if-then statements since they are harder to read and error-prone to maintain.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/AvoidDeeplyNestedIfStmtsRule.java">net.sourceforge.pmd.lang.java.rule.design.AvoidDeeplyNestedIfStmtsRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">bar</span><span class="o">(</span><span class="kt">int</span> <span class="n">x</span><span class="o">,</span> <span class="kt">int</span> <span class="n">y</span><span class="o">,</span> <span class="kt">int</span> <span class="n">z</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">x</span><span class="o">&gt;</span><span class="n">y</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">y</span><span class="o">&gt;</span><span class="n">z</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">z</span><span class="o">==</span><span class="n">x</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">// !! too deep</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>problemDepth</td>
<td>3</td>
<td>The if statement depth reporting threshold</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/AvoidDeeplyNestedIfStmts"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/AvoidDeeplyNestedIfStmts"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"problemDepth"</span> <span class="na">value=</span><span class="s">"3"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="avoidrethrowingexception">AvoidRethrowingException</h2>
<p><strong>Since:</strong> PMD 3.8</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Catch blocks that merely rethrow a caught exception only add to code size and runtime complexity.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">CatchClause</span><span class="p">[</span><span class="w">
</span><span class="nt">CatchParameter</span><span class="o">/</span><span class="nt">VariableId</span><span class="err">/</span><span class="na">@Name</span><span class="w">
</span><span class="err">=</span><span class="w"> </span><span class="nt">Block</span><span class="p">[</span><span class="na">@Size</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="m">1</span><span class="p">]</span><span class="o">/</span><span class="nt">ThrowStatement</span><span class="o">/</span><span class="nt">VariableAccess</span><span class="err">/</span><span class="na">@Name</span><span class="p">]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kt">void</span> <span class="nf">bar</span><span class="o">()</span> <span class="o">{</span>
<span class="k">try</span> <span class="o">{</span>
<span class="c1">// do something</span>
<span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="nc">SomeException</span> <span class="n">se</span><span class="o">)</span> <span class="o">{</span>
<span class="k">throw</span> <span class="n">se</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/AvoidRethrowingException"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="avoidthrowingnewinstanceofsameexception">AvoidThrowingNewInstanceOfSameException</h2>
<p><strong>Since:</strong> PMD 4.2.5</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Catch blocks that merely rethrow a caught exception wrapped inside a new instance of the same type only add to
code size and runtime complexity.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">CatchClause</span><span class="w">
</span><span class="p">[</span><span class="nf">count</span><span class="p">(</span><span class="nt">Block</span><span class="err">/*</span><span class="p">)</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="m">1</span><span class="p">]</span><span class="w">
</span><span class="p">[</span><span class="nt">CatchParameter</span><span class="o">/</span><span class="nt">ClassType</span><span class="err">/</span><span class="na">@SimpleName</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nt">Block</span><span class="o">/</span><span class="nt">ThrowStatement</span><span class="o">/</span><span class="nt">ConstructorCall</span><span class="o">/</span><span class="nt">ClassType</span><span class="err">/</span><span class="na">@SimpleName</span><span class="p">]</span><span class="w">
</span><span class="p">[</span><span class="nt">Block</span><span class="o">/</span><span class="nt">ThrowStatement</span><span class="o">/</span><span class="nt">ConstructorCall</span><span class="o">/</span><span class="nt">ArgumentList</span><span class="err">/</span><span class="na">@Size</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="m">1</span><span class="p">]</span><span class="w">
</span><span class="o">/</span><span class="nt">Block</span><span class="o">/</span><span class="nt">ThrowStatement</span><span class="o">/</span><span class="nt">ConstructorCall</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kt">void</span> <span class="nf">bar</span><span class="o">()</span> <span class="o">{</span>
<span class="k">try</span> <span class="o">{</span>
<span class="c1">// do something</span>
<span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="nc">SomeException</span> <span class="n">se</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">// harmless comment</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nf">SomeException</span><span class="o">(</span><span class="n">se</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/AvoidThrowingNewInstanceOfSameException"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="avoidthrowingnullpointerexception">AvoidThrowingNullPointerException</h2>
<p><strong>Since:</strong> PMD 1.8</p>
<p><strong>Priority:</strong> High (1)</p>
<p>Avoid throwing NullPointerExceptions manually. These are confusing because most people will assume that the
virtual machine threw it. To avoid a method being called with a null parameter, you may consider
using an IllegalArgumentException instead, making it clearly seen as a programmer-initiated exception.
However, there are better ways to handle this:</p>
<blockquote>
<p><em>Effective Java, 3rd Edition, Item 72: Favor the use of standard exceptions</em></p>
<p>Arguably, every erroneous method invocation boils down to an illegal argument or state,
but other exceptions are standardly used for certain kinds of illegal arguments and states.
If a caller passes null in some parameter for which null values are prohibited, convention dictates that
NullPointerException be thrown rather than IllegalArgumentException.</p>
</blockquote>
<p>To implement that, you are encouraged to use <code class="language-plaintext highlighter-rouge">java.util.Objects.requireNonNull()</code>
(introduced in Java 1.7). This method is designed primarily for doing parameter
validation in methods and constructors with multiple parameters.</p>
<p>Your parameter validation could thus look like the following:</p>
<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>public class Foo {
private String exampleValue;
void setExampleValue(String exampleValue) {
// check, throw and assignment in a single standard call
this.exampleValue = Objects.requireNonNull(exampleValue, "exampleValue must not be null!");
}
}
</code></pre></div></div>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/AvoidThrowingNullPointerExceptionRule.java">net.sourceforge.pmd.lang.java.rule.design.AvoidThrowingNullPointerExceptionRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kt">void</span> <span class="nf">bar</span><span class="o">()</span> <span class="o">{</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nf">NullPointerException</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/AvoidThrowingNullPointerException"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="avoidthrowingrawexceptiontypes">AvoidThrowingRawExceptionTypes</h2>
<p><strong>Since:</strong> PMD 1.8</p>
<p><strong>Priority:</strong> High (1)</p>
<p>Avoid throwing certain exception types. Rather than throw a raw RuntimeException, Throwable,
Exception, or Error, use a subclassed exception or error instead.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">ThrowStatement</span><span class="o">//</span><span class="nt">ConstructorCall</span><span class="w">
</span><span class="o">/</span><span class="nt">ClassType</span><span class="p">[</span><span class="w">
</span><span class="nn">pmd-java:</span><span class="nf">typeIsExactly</span><span class="p">(</span><span class="s1">'java.lang.Throwable'</span><span class="p">)</span><span class="w">
</span><span class="ow">or</span><span class="w">
</span><span class="nn">pmd-java:</span><span class="nf">typeIsExactly</span><span class="p">(</span><span class="s1">'java.lang.Exception'</span><span class="p">)</span><span class="w">
</span><span class="ow">or</span><span class="w">
</span><span class="nn">pmd-java:</span><span class="nf">typeIsExactly</span><span class="p">(</span><span class="s1">'java.lang.Error'</span><span class="p">)</span><span class="w">
</span><span class="ow">or</span><span class="w">
</span><span class="nn">pmd-java:</span><span class="nf">typeIsExactly</span><span class="p">(</span><span class="s1">'java.lang.RuntimeException'</span><span class="p">)</span><span class="w">
</span><span class="p">]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">bar</span><span class="o">()</span> <span class="kd">throws</span> <span class="nc">Exception</span> <span class="o">{</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nf">Exception</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/AvoidThrowingRawExceptionTypes"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="avoiduncheckedexceptionsinsignatures">AvoidUncheckedExceptionsInSignatures</h2>
<p><strong>Since:</strong> PMD 6.13.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Reports unchecked exceptions in the <code class="language-plaintext highlighter-rouge">throws</code> clause of a method or constructor.
Java doesn’t force the caller to handle an unchecked exception,
so it’s unnecessary except for documentation. A better practice is to document the
exceptional cases with a <code class="language-plaintext highlighter-rouge">@throws</code> Javadoc tag, which allows being more descriptive.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">ThrowsList</span><span class="o">/</span><span class="nt">ClassType</span><span class="p">[</span><span class="nn">pmd-java:</span><span class="nf">typeIs</span><span class="p">(</span><span class="s1">'java.lang.RuntimeException'</span><span class="p">)]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kt">void</span> <span class="nf">foo</span><span class="o">()</span> <span class="kd">throws</span> <span class="nc">RuntimeException</span> <span class="o">{</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/AvoidUncheckedExceptionsInSignatures"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="classwithonlyprivateconstructorsshouldbefinal">ClassWithOnlyPrivateConstructorsShouldBeFinal</h2>
<p><strong>Since:</strong> PMD 4.1</p>
<p><strong>Priority:</strong> High (1)</p>
<p>Reports classes that may be made final because they cannot be extended from outside
their compilation unit anyway. This is because all their constructors are private,
so a subclass could not call the super constructor.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/ClassWithOnlyPrivateConstructorsShouldBeFinalRule.java">net.sourceforge.pmd.lang.java.rule.design.ClassWithOnlyPrivateConstructorsShouldBeFinalRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span> <span class="c1">//Should be final</span>
<span class="kd">private</span> <span class="nf">Foo</span><span class="o">()</span> <span class="o">{</span> <span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/ClassWithOnlyPrivateConstructorsShouldBeFinal"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="cognitivecomplexity">CognitiveComplexity</h2>
<p><strong>Since:</strong> PMD 6.35.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Methods that are highly complex are difficult to read and more costly to maintain. If you include too much decisional
logic within a single method, you make its behavior hard to understand and more difficult to modify.</p>
<p>Cognitive complexity is a measure of how difficult it is for humans to read and understand a method. Code that contains
a break in the control flow is more complex, whereas the use of language shorthands doesn’t increase the level of
complexity. Nested control flows can make a method more difficult to understand, with each additional nesting of the
control flow leading to an increase in cognitive complexity.</p>
<p>Information about Cognitive complexity can be found in the original paper here:
<a href="https://www.sonarsource.com/docs/CognitiveComplexity.pdf">https://www.sonarsource.com/docs/CognitiveComplexity.pdf</a></p>
<p>By default, this rule reports methods with a complexity of 15 or more. Reported methods should be broken down into less
complex components.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/CognitiveComplexityRule.java">net.sourceforge.pmd.lang.java.rule.design.CognitiveComplexityRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="c1">// Has a cognitive complexity of 0</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">createAccount</span><span class="o">()</span> <span class="o">{</span>
<span class="nc">Account</span> <span class="n">account</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Account</span><span class="o">(</span><span class="s">"PMD"</span><span class="o">);</span>
<span class="c1">// save account</span>
<span class="o">}</span>
<span class="c1">// Has a cognitive complexity of 1</span>
<span class="kd">public</span> <span class="nc">Boolean</span> <span class="nf">setPhoneNumberIfNotExisting</span><span class="o">(</span><span class="nc">Account</span> <span class="n">a</span><span class="o">,</span> <span class="nc">String</span> <span class="n">phone</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">a</span><span class="o">.</span><span class="na">phone</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// +1</span>
<span class="n">a</span><span class="o">.</span><span class="na">phone</span> <span class="o">=</span> <span class="n">phone</span><span class="o">;</span>
<span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
<span class="o">}</span>
<span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
<span class="o">}</span>
<span class="c1">// Has a cognitive complexity of 4</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">updateContacts</span><span class="o">(</span><span class="nc">List</span><span class="o">&lt;</span><span class="nc">Contact</span><span class="o">&gt;</span> <span class="n">contacts</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">List</span><span class="o">&lt;</span><span class="nc">Contact</span><span class="o">&gt;</span> <span class="n">contactsToUpdate</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">ArrayList</span><span class="o">&lt;</span><span class="nc">Contact</span><span class="o">&gt;();</span>
<span class="k">for</span> <span class="o">(</span><span class="nc">Contact</span> <span class="n">contact</span> <span class="o">:</span> <span class="n">contacts</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// +1</span>
<span class="k">if</span> <span class="o">(</span><span class="n">contact</span><span class="o">.</span><span class="na">department</span><span class="o">.</span><span class="na">equals</span><span class="o">(</span><span class="s">"Finance"</span><span class="o">))</span> <span class="o">{</span> <span class="c1">// +2 (nesting = 1)</span>
<span class="n">contact</span><span class="o">.</span><span class="na">title</span> <span class="o">=</span> <span class="s">"Finance Specialist"</span><span class="o">;</span>
<span class="n">contactsToUpdate</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">contact</span><span class="o">);</span>
<span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">contact</span><span class="o">.</span><span class="na">department</span><span class="o">.</span><span class="na">equals</span><span class="o">(</span><span class="s">"Sales"</span><span class="o">))</span> <span class="o">{</span> <span class="c1">// +1</span>
<span class="n">contact</span><span class="o">.</span><span class="na">title</span> <span class="o">=</span> <span class="s">"Sales Specialist"</span><span class="o">;</span>
<span class="n">contactsToUpdate</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">contact</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="c1">// save contacts</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>reportLevel</td>
<td>15</td>
<td>Cognitive Complexity reporting threshold</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/CognitiveComplexity"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/CognitiveComplexity"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"reportLevel"</span> <span class="na">value=</span><span class="s">"15"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="collapsibleifstatements">CollapsibleIfStatements</h2>
<p><strong>Since:</strong> PMD 3.1</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Reports nested ‘if’ statements that can be merged together by joining their
conditions with a boolean <code class="language-plaintext highlighter-rouge">&amp;&amp;</code> operator in between.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">IfStatement</span><span class="p">[</span><span class="na">@Else</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nf">false</span><span class="p">()]</span><span class="o">/</span><span class="nt">IfStatement</span><span class="p">[</span><span class="na">@Else</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nf">false</span><span class="p">()]</span><span class="w">
</span><span class="p">|</span><span class="w">
</span><span class="o">//</span><span class="nt">IfStatement</span><span class="p">[</span><span class="na">@Else</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nf">false</span><span class="p">()]</span><span class="o">/</span><span class="nt">Block</span><span class="p">[</span><span class="nf">count</span><span class="p">(</span><span class="err">*</span><span class="p">)</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="m">1</span><span class="p">]</span><span class="o">/</span><span class="nt">IfStatement</span><span class="p">[</span><span class="na">@Else</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nf">false</span><span class="p">()]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kt">void</span> <span class="nf">bar</span><span class="o">()</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">x</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// original implementation</span>
<span class="k">if</span> <span class="o">(</span><span class="n">y</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">// do stuff</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="kt">void</span> <span class="nf">bar</span><span class="o">()</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">x</span> <span class="o">&amp;&amp;</span> <span class="n">y</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// clearer implementation</span>
<span class="c1">// do stuff</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/CollapsibleIfStatements"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="couplingbetweenobjects">CouplingBetweenObjects</h2>
<p><strong>Since:</strong> PMD 1.04</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>This rule counts the number of unique attributes, local variables, and return types within an object.
A number higher than the specified threshold can indicate a high degree of coupling.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/CouplingBetweenObjectsRule.java">net.sourceforge.pmd.lang.java.rule.design.CouplingBetweenObjectsRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">com.Blah</span><span class="o">;</span>
<span class="kn">import</span> <span class="nn">org.Bar</span><span class="o">;</span>
<span class="kn">import</span> <span class="nn">org.Bardo</span><span class="o">;</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">private</span> <span class="nc">Blah</span> <span class="n">var1</span><span class="o">;</span>
<span class="kd">private</span> <span class="nc">Bar</span> <span class="n">var2</span><span class="o">;</span>
<span class="c1">//followed by many imports of unique objects</span>
<span class="nc">ObjectC</span> <span class="nf">doWork</span><span class="o">()</span> <span class="o">{</span>
<span class="nc">Bardo</span> <span class="n">var55</span><span class="o">;</span>
<span class="nc">ObjectA</span> <span class="n">var44</span><span class="o">;</span>
<span class="nc">ObjectZ</span> <span class="n">var93</span><span class="o">;</span>
<span class="k">return</span> <span class="nf">something</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>threshold</td>
<td>20</td>
<td>Unique type reporting threshold</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/CouplingBetweenObjects"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/CouplingBetweenObjects"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"threshold"</span> <span class="na">value=</span><span class="s">"20"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="cyclomaticcomplexity">CyclomaticComplexity</h2>
<p><strong>Since:</strong> PMD 1.03</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>The complexity of methods directly affects maintenance costs and readability. Concentrating too much decisional logic
in a single method makes its behaviour hard to read and change.</p>
<p>Cyclomatic complexity assesses the complexity of a method by counting the number of decision points in a method,
plus one for the method entry. Decision points are places where the control flow jumps to another place in the
program. As such, they include all control flow statements, such as <code class="language-plaintext highlighter-rouge">if</code>, <code class="language-plaintext highlighter-rouge">while</code>, <code class="language-plaintext highlighter-rouge">for</code>, and <code class="language-plaintext highlighter-rouge">case</code>. For more
details on the calculation, see the documentation <a href="https://docs.pmd-code.org/apidocs/pmd-java/7.4.0-SNAPSHOT/net/sourceforge/pmd/lang/java/metrics/JavaMetrics.html#CYCLO"><code>CYCLO</code></a>.</p>
<p>Generally, numbers ranging from 1-4 denote low complexity, 5-7 denote moderate complexity, 8-10 denote
high complexity, and 11+ is very high complexity. By default, this rule reports methods with a complexity &gt;= 10.
Additionally, classes with many methods of moderate complexity get reported as well once the total of their
methods’ complexities reaches 80, even if none of the methods was directly reported.</p>
<p>Reported methods should be broken down into several smaller methods. Reported classes should probably be broken down
into subcomponents.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/CyclomaticComplexityRule.java">net.sourceforge.pmd.lang.java.rule.design.CyclomaticComplexityRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kt">void</span> <span class="nf">baseCyclo</span><span class="o">()</span> <span class="o">{</span> <span class="c1">// Cyclo = 1</span>
<span class="n">highCyclo</span><span class="o">();</span>
<span class="o">}</span>
<span class="kt">void</span> <span class="nf">highCyclo</span><span class="o">()</span> <span class="o">{</span> <span class="c1">// Cyclo = 10: reported!</span>
<span class="kt">int</span> <span class="n">x</span> <span class="o">=</span> <span class="mi">0</span><span class="o">,</span> <span class="n">y</span> <span class="o">=</span> <span class="mi">2</span><span class="o">;</span>
<span class="kt">boolean</span> <span class="n">a</span> <span class="o">=</span> <span class="kc">false</span><span class="o">,</span> <span class="n">b</span> <span class="o">=</span> <span class="kc">true</span><span class="o">;</span>
<span class="k">if</span> <span class="o">(</span><span class="n">a</span> <span class="o">&amp;&amp;</span> <span class="o">(</span><span class="n">y</span> <span class="o">==</span> <span class="mi">1</span> <span class="o">?</span> <span class="n">b</span> <span class="o">:</span> <span class="kc">true</span><span class="o">))</span> <span class="o">{</span> <span class="c1">// +3</span>
<span class="k">if</span> <span class="o">(</span><span class="n">y</span> <span class="o">==</span> <span class="n">x</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// +1</span>
<span class="k">while</span> <span class="o">(</span><span class="kc">true</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// +1</span>
<span class="k">if</span> <span class="o">(</span><span class="n">x</span><span class="o">++</span> <span class="o">&lt;</span> <span class="mi">20</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// +1</span>
<span class="k">break</span><span class="o">;</span> <span class="c1">// +1</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">y</span> <span class="o">==</span> <span class="n">t</span> <span class="o">&amp;&amp;</span> <span class="o">!</span><span class="n">d</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// +2</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">a</span> <span class="o">?</span> <span class="n">y</span> <span class="o">:</span> <span class="n">x</span><span class="o">;</span> <span class="c1">// +1</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
<span class="n">x</span> <span class="o">=</span> <span class="mi">2</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>classReportLevel</td>
<td>80</td>
<td>Total class complexity reporting threshold</td>
</tr>
<tr>
<td>methodReportLevel</td>
<td>10</td>
<td>Cyclomatic complexity reporting threshold</td>
</tr>
<tr>
<td>cycloOptions</td>
<td> </td>
<td>Choose options for the computation of Cyclo</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/CyclomaticComplexity"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/CyclomaticComplexity"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"classReportLevel"</span> <span class="na">value=</span><span class="s">"80"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"methodReportLevel"</span> <span class="na">value=</span><span class="s">"10"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"cycloOptions"</span> <span class="na">value=</span><span class="s">""</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="dataclass">DataClass</h2>
<p><strong>Since:</strong> PMD 6.0.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Data Classes are simple data holders, which reveal most of their state, and
without complex functionality. The lack of functionality may indicate that
their behaviour is defined elsewhere, which is a sign of poor data-behaviour
proximity. By directly exposing their internals, Data Classes break encapsulation,
and therefore reduce the system’s maintainability and understandability. Moreover,
classes tend to strongly rely on their data representation, which makes for a brittle
design.</p>
<p>Refactoring a Data Class should focus on restoring a good data-behaviour proximity. In
most cases, that means moving the operations defined on the data back into the class.
In some other cases it may make sense to remove entirely the class and move the data
into the former client classes.</p>
<p>The rule uses metrics to implement its detection strategy. The violation message
gives information about the values of these metrics:</p>
<ul>
<li>WMC: a class complexity measure for a class, see <a href="https://docs.pmd-code.org/apidocs/pmd-java/7.4.0-SNAPSHOT/net/sourceforge/pmd/lang/java/metrics/JavaMetrics.html#WEIGHED_METHOD_COUNT"><code>WEIGHED_METHOD_COUNT</code></a></li>
<li>WOC: a ‘non-triviality’ measure for a class, see <a href="https://docs.pmd-code.org/apidocs/pmd-java/7.4.0-SNAPSHOT/net/sourceforge/pmd/lang/java/metrics/JavaMetrics.html#WEIGHT_OF_CLASS"><code>WEIGHT_OF_CLASS</code></a></li>
<li>NOPA: number of public attributes, see <a href="https://docs.pmd-code.org/apidocs/pmd-java/7.4.0-SNAPSHOT/net/sourceforge/pmd/lang/java/metrics/JavaMetrics.html#NUMBER_OF_PUBLIC_FIELDS"><code>NUMBER_OF_PUBLIC_FIELDS</code></a></li>
<li>NOAM: number of public accessor methods, see <a href="https://docs.pmd-code.org/apidocs/pmd-java/7.4.0-SNAPSHOT/net/sourceforge/pmd/lang/java/metrics/JavaMetrics.html#NUMBER_OF_ACCESSORS"><code>NUMBER_OF_ACCESSORS</code></a></li>
</ul>
<p>The rule identifies a god class by looking for classes which have all of the following properties:</p>
<ul>
<li>High NOPA + NOAM</li>
<li>Low WOC</li>
<li>Low WMC</li>
</ul>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/DataClassRule.java">net.sourceforge.pmd.lang.java.rule.design.DataClassRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">DataClass</span> <span class="o">{</span>
<span class="c1">// class exposes public attributes</span>
<span class="kd">public</span> <span class="nc">String</span> <span class="n">name</span> <span class="o">=</span> <span class="s">""</span><span class="o">;</span>
<span class="kd">public</span> <span class="kt">int</span> <span class="n">bar</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
<span class="kd">public</span> <span class="kt">int</span> <span class="n">na</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
<span class="kd">private</span> <span class="kt">int</span> <span class="n">bee</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
<span class="c1">// and private ones through getters</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">setBee</span><span class="o">(</span><span class="kt">int</span> <span class="n">n</span><span class="o">)</span> <span class="o">{</span>
<span class="n">bee</span> <span class="o">=</span> <span class="n">n</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/DataClass"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="donotextendjavalangerror">DoNotExtendJavaLangError</h2>
<p><strong>Since:</strong> PMD 4.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Errors are system exceptions. Do not extend them.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">ClassDeclaration</span><span class="o">/</span><span class="nt">ExtendsList</span><span class="o">/</span><span class="nt">ClassType</span><span class="p">[</span><span class="nn">pmd-java:</span><span class="nf">typeIs</span><span class="p">(</span><span class="s1">'java.lang.Error'</span><span class="p">)]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="kd">extends</span> <span class="nc">Error</span> <span class="o">{</span> <span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/DoNotExtendJavaLangError"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="exceptionasflowcontrol">ExceptionAsFlowControl</h2>
<p><strong>Since:</strong> PMD 1.8</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>This rule reports exceptions thrown and caught in an enclosing try statement.
This use of exceptions as a form of <code class="language-plaintext highlighter-rouge">goto</code> statement is discouraged, as that may
hide actual exceptions, and obscures control flow, especially when debugging.
To fix a violation, add the necessary validation or use an alternate control structure.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/ExceptionAsFlowControlRule.java">net.sourceforge.pmd.lang.java.rule.design.ExceptionAsFlowControlRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kt">void</span> <span class="nf">bar</span><span class="o">()</span> <span class="o">{</span>
<span class="k">try</span> <span class="o">{</span>
<span class="k">try</span> <span class="o">{</span>
<span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="nc">Exception</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nf">WrapperException</span><span class="o">(</span><span class="n">e</span><span class="o">);</span>
<span class="c1">// this is essentially a GOTO to the WrapperException catch block</span>
<span class="o">}</span>
<span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="nc">WrapperException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">// do some more stuff</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/ExceptionAsFlowControl"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="excessiveimports">ExcessiveImports</h2>
<p><strong>Since:</strong> PMD 1.04</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>A high number of imports can indicate a high degree of coupling within an object. This rule
counts the number of unique imports and reports a violation if the count is above the
user-specified threshold.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/ExcessiveImportsRule.java">net.sourceforge.pmd.lang.java.rule.design.ExcessiveImportsRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">blah.blah.Baz</span><span class="o">;</span>
<span class="kn">import</span> <span class="nn">blah.blah.Bif</span><span class="o">;</span>
<span class="c1">// 28 others from the same package elided</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">doWork</span><span class="o">()</span> <span class="o">{}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>minimum</td>
<td>30</td>
<td>Threshold above which a node is reported</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/ExcessiveImports"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/ExcessiveImports"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"minimum"</span> <span class="na">value=</span><span class="s">"30"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="excessiveparameterlist">ExcessiveParameterList</h2>
<p><strong>Since:</strong> PMD 0.9</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Methods with numerous parameters are a challenge to maintain, especially if most of them share the
same datatype. These situations usually denote the need for new objects to wrap the numerous parameters.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/ExcessiveParameterListRule.java">net.sourceforge.pmd.lang.java.rule.design.ExcessiveParameterListRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kt">void</span> <span class="nf">addPerson</span><span class="o">(</span> <span class="c1">// too many arguments liable to be mixed up</span>
<span class="kt">int</span> <span class="n">birthYear</span><span class="o">,</span> <span class="kt">int</span> <span class="n">birthMonth</span><span class="o">,</span> <span class="kt">int</span> <span class="n">birthDate</span><span class="o">,</span> <span class="kt">int</span> <span class="n">height</span><span class="o">,</span> <span class="kt">int</span> <span class="n">weight</span><span class="o">,</span> <span class="kt">int</span> <span class="n">ssn</span><span class="o">)</span> <span class="o">{</span>
<span class="o">.</span> <span class="o">.</span> <span class="o">.</span> <span class="o">.</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">addPerson</span><span class="o">(</span> <span class="c1">// preferred approach</span>
<span class="nc">Date</span> <span class="n">birthdate</span><span class="o">,</span> <span class="nc">BodyMeasurements</span> <span class="n">measurements</span><span class="o">,</span> <span class="kt">int</span> <span class="n">ssn</span><span class="o">)</span> <span class="o">{</span>
<span class="o">.</span> <span class="o">.</span> <span class="o">.</span> <span class="o">.</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>minimum</td>
<td>10</td>
<td>Threshold above which a node is reported</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/ExcessiveParameterList"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/ExcessiveParameterList"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"minimum"</span> <span class="na">value=</span><span class="s">"10"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="excessivepubliccount">ExcessivePublicCount</h2>
<p><strong>Since:</strong> PMD 1.04</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Classes with large numbers of public methods and attributes require disproportionate testing efforts
since combinational side effects grow rapidly and increase risk. Refactoring these classes into
smaller ones not only increases testability and reliability but also allows new variations to be
developed easily.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/ExcessivePublicCountRule.java">net.sourceforge.pmd.lang.java.rule.design.ExcessivePublicCountRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">public</span> <span class="nc">String</span> <span class="n">value</span><span class="o">;</span>
<span class="kd">public</span> <span class="nc">Bar</span> <span class="n">something</span><span class="o">;</span>
<span class="kd">public</span> <span class="nc">Variable</span> <span class="kt">var</span><span class="o">;</span>
<span class="c1">// [... more more public attributes ...]</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">doWork</span><span class="o">()</span> <span class="o">{}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">doMoreWork</span><span class="o">()</span> <span class="o">{}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">doWorkAgain</span><span class="o">()</span> <span class="o">{}</span>
<span class="c1">// [... more more public methods ...]</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>minimum</td>
<td>45</td>
<td>Threshold above which a node is reported</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/ExcessivePublicCount"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/ExcessivePublicCount"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"minimum"</span> <span class="na">value=</span><span class="s">"45"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="finalfieldcouldbestatic">FinalFieldCouldBeStatic</h2>
<p><strong>Since:</strong> PMD 1.1</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>If a final field is assigned to a compile-time constant, it could be made static, thus saving overhead
in each object at runtime.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">FieldDeclaration</span><span class="w">
</span><span class="p">[</span><span class="nn">pmd-java:</span><span class="ow">mod</span><span class="kr">if</span><span class="nf">iers</span><span class="p">()</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'final'</span><span class="p">]</span><span class="w">
</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="nn">pmd-java:</span><span class="ow">mod</span><span class="kr">if</span><span class="nf">iers</span><span class="p">()</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'static'</span><span class="p">)]</span><span class="w">
</span><span class="p">[</span><span class="ow">not</span><span class="p">(.</span><span class="o">/</span><span class="kn">ancestor::</span><span class="nt">ClassDeclaration</span><span class="p">[</span><span class="m">1</span><span class="p">][</span><span class="nn">pmd-java:</span><span class="nf">hasAnnotation</span><span class="p">(</span><span class="s1">'lombok.experimental.UtilityClass'</span><span class="p">)])]</span><span class="w">
</span><span class="p">[</span><span class="ow">not</span><span class="p">(.</span><span class="o">//</span><span class="nt">Annotation</span><span class="p">[</span><span class="nn">pmd-java:</span><span class="nf">typeIs</span><span class="p">(</span><span class="s1">'lombok.Builder.Default'</span><span class="p">)])]</span><span class="w">
</span><span class="o">/</span><span class="nt">VariableDeclarator</span><span class="p">[</span><span class="o">*</span><span class="p">[</span><span class="nf">last</span><span class="p">()][</span><span class="na">@CompileTimeConstant</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nf">true</span><span class="p">()</span><span class="w">
</span><span class="ow">or</span><span class="w"> </span><span class="kn">self::</span><span class="nt">NullLiteral</span><span class="w">
</span><span class="ow">or</span><span class="w"> </span><span class="kn">self::</span><span class="nt">VariableAccess</span><span class="p">[</span><span class="na">@Name</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="o">//</span><span class="nt">FieldDeclaration</span><span class="p">[</span><span class="nn">pmd-java:</span><span class="ow">mod</span><span class="kr">if</span><span class="nf">iers</span><span class="p">()</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'static'</span><span class="p">]</span><span class="o">/</span><span class="nt">VariableDeclarator</span><span class="o">/</span><span class="nt">VariableId</span><span class="err">/</span><span class="na">@Name</span><span class="p">]</span><span class="w">
</span><span class="ow">or</span><span class="w"> </span><span class="kn">self::</span><span class="nt">FieldAccess</span><span class="w">
</span><span class="ow">or</span><span class="w"> </span><span class="kn">self::</span><span class="nt">ArrayAllocation</span><span class="o">/</span><span class="nt">ArrayType</span><span class="o">/</span><span class="nt">ArrayDimensions</span><span class="o">/</span><span class="nt">ArrayDimExpr</span><span class="o">/</span><span class="nt">NumericLiteral</span><span class="p">[</span><span class="na">@IntLiteral</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nf">true</span><span class="p">()][</span><span class="na">@Image</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s2">"0"</span><span class="p">]]]</span><span class="w">
</span><span class="o">/</span><span class="nt">VariableId</span><span class="w">
</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="na">@Name</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="o">//</span><span class="nt">MethodDeclaration</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="nn">pmd-java:</span><span class="ow">mod</span><span class="kr">if</span><span class="nf">iers</span><span class="p">()</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'static'</span><span class="p">)]</span><span class="w">
</span><span class="o">//</span><span class="nt">SynchronizedStatement</span><span class="err">/</span><span class="p">(</span><span class="nt">VariableAccess</span><span class="p">|</span><span class="nt">FieldAccess</span><span class="p">[</span><span class="nt">ThisExpression</span><span class="p">])</span><span class="err">/</span><span class="na">@Name</span><span class="p">)]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kd">final</span> <span class="kt">int</span> <span class="no">BAR</span> <span class="o">=</span> <span class="mi">42</span><span class="o">;</span> <span class="c1">// this could be static and save some space</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/FinalFieldCouldBeStatic"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="godclass">GodClass</h2>
<p><strong>Since:</strong> PMD 5.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>The God Class rule detects the God Class design flaw using metrics. God classes do too many things,
are very big and overly complex. They should be split apart to be more object-oriented.
The rule uses the detection strategy described in "Object-Oriented Metrics in Practice".
The violations are reported against the entire class.</p>
<p>The rule uses metrics to implement its detection strategy. The violation message
gives information about the values of these metrics:</p>
<ul>
<li>WMC: a class complexity measure, see <a href="https://docs.pmd-code.org/apidocs/pmd-java/7.4.0-SNAPSHOT/net/sourceforge/pmd/lang/java/metrics/JavaMetrics.html#WEIGHED_METHOD_COUNT"><code>WEIGHED_METHOD_COUNT</code></a></li>
<li>ATFD: a measure of how much data external data the class uses, see <a href="https://docs.pmd-code.org/apidocs/pmd-java/7.4.0-SNAPSHOT/net/sourceforge/pmd/lang/java/metrics/JavaMetrics.html#ACCESS_TO_FOREIGN_DATA"><code>ACCESS_TO_FOREIGN_DATA</code></a></li>
<li>TCC: a measure of how tightly related the methods are, see <a href="https://docs.pmd-code.org/apidocs/pmd-java/7.4.0-SNAPSHOT/net/sourceforge/pmd/lang/java/metrics/JavaMetrics.html#TIGHT_CLASS_COHESION"><code>TIGHT_CLASS_COHESION</code></a></li>
</ul>
<p>The rule identifies a god class by looking for classes which have all of the following properties:</p>
<ul>
<li>High WMC</li>
<li>High ATFD</li>
<li>Low TCC</li>
</ul>
<p>See also the reference:</p>
<p>Michele Lanza and Radu Marinescu. <em>Object-Oriented Metrics in Practice:
Using Software Metrics to Characterize, Evaluate, and Improve the Design
of Object-Oriented Systems.</em> Springer, Berlin, 1 edition, October 2006. Page 80.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/GodClassRule.java">net.sourceforge.pmd.lang.java.rule.design.GodClassRule</a></p>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/GodClass"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="immutablefield">ImmutableField</h2>
<p><strong>Since:</strong> PMD 2.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Reports non-final fields whose value never changes once object initialization ends,
and hence may be marked final.</p>
<p>Note that this rule does not enforce that the field value be deeply immutable itself.
An object can still have mutable state, even if all its member fields are declared final.
This is referred to as shallow immutability. For more information on mutability,
see <em>Effective Java, 3rd Edition, Item 17: Minimize mutability</em>.</p>
<p>Limitations: We can only check private fields for now.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/ImmutableFieldRule.java">net.sourceforge.pmd.lang.java.rule.design.ImmutableFieldRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">private</span> <span class="kt">int</span> <span class="n">x</span><span class="o">;</span> <span class="c1">// could be final</span>
<span class="kd">public</span> <span class="nf">Foo</span><span class="o">()</span> <span class="o">{</span>
<span class="n">x</span> <span class="o">=</span> <span class="mi">7</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">foo</span><span class="o">()</span> <span class="o">{</span>
<span class="kt">int</span> <span class="n">a</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="mi">2</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/ImmutableField"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="invalidjavabean">InvalidJavaBean</h2>
<p><strong>Since:</strong> PMD 6.52.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Identifies beans, that don’t follow the <a href="https://download.oracle.com/otndocs/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/">JavaBeans API specification</a>.</p>
<p>Each non-static field should have both a getter and a setter method. If the field is just used internally and is not
a bean property, then the field should be marked as <code class="language-plaintext highlighter-rouge">transient</code>.</p>
<p>The rule verifies that the type of the field is the same as the result type of the getter. And that this type matches
the type used in the setter.</p>
<p>The rule also checks, that there is a no-arg or default constructor available.</p>
<p>Optionally the rule also verifies, that the bean implements <code class="language-plaintext highlighter-rouge">java.io.Serializable</code>. While this is a requirement for the
original JavaBeans specification, frameworks nowadays don’t strictly require this anymore.</p>
<p>In order to avoid many false positives in classes that are not beans, the rule needs to be explicitly
enabled by configuring the property <code class="language-plaintext highlighter-rouge">packages</code>.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/InvalidJavaBeanRule.java">net.sourceforge.pmd.lang.java.rule.design.InvalidJavaBeanRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">package</span> <span class="nn">org.example.beans</span><span class="o">;</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">MyBean</span> <span class="o">{</span> <span class="c1">// &lt;-- bean is not serializable, missing "implements Serializable"</span>
<span class="kd">private</span> <span class="nc">String</span> <span class="n">label</span><span class="o">;</span> <span class="c1">// &lt;-- missing setter for property "label"</span>
<span class="kd">public</span> <span class="nc">String</span> <span class="nf">getLabel</span><span class="o">()</span> <span class="o">{</span>
<span class="k">return</span> <span class="n">label</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>ensureSerialization</td>
<td>false</td>
<td>Require that beans implement java.io.Serializable.</td>
</tr>
<tr>
<td>packages</td>
<td>org.example.beans</td>
<td>Consider classes in only these package to be beans. Set to an empty value to check all classes.</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/InvalidJavaBean"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/InvalidJavaBean"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"ensureSerialization"</span> <span class="na">value=</span><span class="s">"false"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"packages"</span> <span class="na">value=</span><span class="s">"org.example.beans"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="lawofdemeter">LawOfDemeter</h2>
<p><strong>Since:</strong> PMD 5.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>The law of Demeter is a simple rule that says "only talk to friends". It forbids
fetching data from "too far away", for some definition of distance, in order to
reduce coupling between classes or objects of different levels of abstraction.</p>
<p>The rule uses a notion of "degree", that quantifies how "far" an object is.
Expressions with too high degree can only be used in certain ways. The degree of
an expression is defined inductively:</p>
<ul>
<li>The degree of <code class="language-plaintext highlighter-rouge">this</code> is 0</li>
<li>The degree of a method parameter is 1</li>
<li>The degree of a new object created in a method is 1</li>
<li>The degree of a static variable is 1</li>
<li>The degree of a field access expression like <code class="language-plaintext highlighter-rouge">expr.field</code> is the degree of <code class="language-plaintext highlighter-rouge">expr</code> plus 1</li>
<li>The degree of a "getter expression" like <code class="language-plaintext highlighter-rouge">expr.getFoo()</code> is the degree of <code class="language-plaintext highlighter-rouge">expr</code> plus 1</li>
<li>The degree of a "transformation expression" like <code class="language-plaintext highlighter-rouge">expr.withFoo("")</code> is the degree of <code class="language-plaintext highlighter-rouge">expr</code></li>
<li>The degree of a variable is the maximum degree of all the assignments that reach it</li>
</ul>
<p>Intuitively, the more you call getters, the more the degree increases. Eventually
the degree reaches the report threshold (property <code class="language-plaintext highlighter-rouge">trustRadius</code>) and the expression
is reported. The details of the calculation are more involved and make room for common
patterns, like usage of collections (objects that are in a list or array have the
same degree as their container), the builder pattern, and getters that do not appear
to break a boundary of abstraction.</p>
<p>Be aware that this rule is prone to many false-positives and low-priority warnings.
You can increase the <code class="language-plaintext highlighter-rouge">trustRadius</code> property to reduce them drastically. The default
<code class="language-plaintext highlighter-rouge">trustRadius</code> of 1 corresponds to the original law of Demeter (you’re only allowed
one getter call on untrusted values). Given some <code class="language-plaintext highlighter-rouge">trustRadius</code> value:</p>
<ul>
<li>expressions of degree lower or equal to <code class="language-plaintext highlighter-rouge">trustRadius</code> are not reported</li>
<li>expressions of degree exactly <code class="language-plaintext highlighter-rouge">trustRadius + 1</code> are reported, unless they are only returned
from the current method, or passed as argument to another method. Without this exception it
would not be possible to extract any information from e.g. method parameters.</li>
<li>values of degree strictly greater than <code class="language-plaintext highlighter-rouge">trustRadius + 1</code> are not reported. The
intuition is that to obtain a value of degree <code class="language-plaintext highlighter-rouge">n &gt; 1</code> then you must use an expression
of degree <code class="language-plaintext highlighter-rouge">n - 1</code>, so if you have <code class="language-plaintext highlighter-rouge">n &gt; trustRadius + 1</code>, there you’re using some value
of degree <code class="language-plaintext highlighter-rouge">trustRadius + 1</code> that will be reported.</li>
</ul>
<p>See also the references:</p>
<ul>
<li>Andrew Hunt, David Thomas, and Ward Cunningham. The Pragmatic Programmer. From Journeyman to Master. Addison-Wesley Longman, Amsterdam, October 1999.;</li>
<li>K.J. Lieberherr and I.M. Holland. Assuring good style for object-oriented programs. Software, IEEE, 6(5):38–48, 1989.;</li>
<li><a href="http://www.ccs.neu.edu/home/lieber/LoD.html">http://www.ccs.neu.edu/home/lieber/LoD.html</a></li>
<li><a href="http://en.wikipedia.org/wiki/Law_of_Demeter">http://en.wikipedia.org/wiki/Law_of_Demeter</a></li>
</ul>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/LawOfDemeterRule.java">net.sourceforge.pmd.lang.java.rule.design.LawOfDemeterRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="cm">/**
* This example will result in one violation.
*/</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">example</span><span class="o">(</span><span class="nc">Bar</span> <span class="n">b</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// b has degree 1</span>
<span class="c1">// `b.getC()` has degree 2, it's breaking a boundary of abstraction and so is reported.</span>
<span class="n">b</span><span class="o">.</span><span class="na">getC</span><span class="o">().</span><span class="na">doIt</span><span class="o">();</span>
<span class="c1">// To respect the law of Demeter, Bar should encapsulate its</span>
<span class="c1">// C member more properly, eg by exposing a method like this:</span>
<span class="n">b</span><span class="o">.</span><span class="na">callDoItOnC</span><span class="o">();</span>
<span class="c1">// a constructor call, not a method call.</span>
<span class="no">D</span> <span class="n">d</span> <span class="o">=</span> <span class="k">new</span> <span class="no">D</span><span class="o">();</span>
<span class="c1">// this method call is ok, because we have create the new</span>
<span class="c1">// instance of D locally.</span>
<span class="n">d</span><span class="o">.</span><span class="na">doSomethingElse</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>trustRadius</td>
<td>1</td>
<td>Maximum degree of trusted data. The default of 1 is the most restrictive.</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/LawOfDemeter"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/LawOfDemeter"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"trustRadius"</span> <span class="na">value=</span><span class="s">"1"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="logicinversion">LogicInversion</h2>
<p><strong>Since:</strong> PMD 5.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Use opposite operator instead of negating the whole expression with a logic complement operator.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">UnaryExpression</span><span class="p">[</span><span class="na">@Operator</span><span class="err">=</span><span class="s1">'!'</span><span class="p">]</span><span class="o">/</span><span class="nt">InfixExpression</span><span class="p">[</span><span class="na">@Operator</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="p">(</span><span class="s1">'=='</span><span class="p">,</span><span class="w"> </span><span class="s1">'!='</span><span class="p">,</span><span class="w"> </span><span class="s1">'&lt;'</span><span class="p">,</span><span class="w"> </span><span class="s1">'&gt;'</span><span class="p">,</span><span class="w"> </span><span class="s1">'&lt;='</span><span class="p">,</span><span class="w"> </span><span class="s1">'&gt;='</span><span class="p">)]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">bar</span><span class="o">(</span><span class="kt">int</span> <span class="n">a</span><span class="o">,</span> <span class="kt">int</span> <span class="n">b</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(!(</span><span class="n">a</span> <span class="o">==</span> <span class="n">b</span><span class="o">))</span> <span class="o">{</span> <span class="c1">// use !=</span>
<span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
<span class="o">}</span>
<span class="k">if</span> <span class="o">(!(</span><span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span><span class="o">))</span> <span class="o">{</span> <span class="c1">// use &gt;=</span>
<span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
<span class="o">}</span>
<span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/LogicInversion"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="loosepackagecoupling">LoosePackageCoupling</h2>
<p><strong>Since:</strong> PMD 5.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Avoid using classes from the configured package hierarchy outside of the package hierarchy,
except when using one of the configured allowed classes.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/LoosePackageCouplingRule.java">net.sourceforge.pmd.lang.java.rule.design.LoosePackageCouplingRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">package</span> <span class="nn">some.package</span><span class="o">;</span>
<span class="kn">import</span> <span class="nn">some.other.package.subpackage.subsubpackage.DontUseThisClass</span><span class="o">;</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Bar</span> <span class="o">{</span>
<span class="nc">DontUseThisClass</span> <span class="n">boo</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">DontUseThisClass</span><span class="o">();</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>packages</td>
<td> </td>
<td>Restricted packages</td>
</tr>
<tr>
<td>classes</td>
<td> </td>
<td>Allowed classes</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/LoosePackageCoupling"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/LoosePackageCoupling"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"packages"</span> <span class="na">value=</span><span class="s">""</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"classes"</span> <span class="na">value=</span><span class="s">""</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="mutablestaticstate">MutableStaticState</h2>
<p><strong>Since:</strong> PMD 6.35.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Non-private static fields should be made constants (or immutable references) by
declaring them final.</p>
<p>Non-private non-final static fields break encapsulation and can lead to hard to find
bugs, since these fields can be modified from anywhere within the program.
Callers can trivially access and modify non-private non-final static fields. Neither
accesses nor modifications can be guarded against, and newly set values cannot
be validated.</p>
<p>If you are using this rule, then you don’t need this
rule <a href="pmd_rules_java_errorprone.html#assignmenttononfinalstatic"><code class="language-plaintext highlighter-rouge">AssignmentToNonFinalStatic</code></a>.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">FieldDeclaration</span><span class="p">[</span><span class="nn">pmd-java:</span><span class="ow">mod</span><span class="kr">if</span><span class="nf">iers</span><span class="p">()</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s2">"static"</span><span class="p">][</span><span class="ow">not</span><span class="p">(</span><span class="nn">pmd-java:</span><span class="ow">mod</span><span class="kr">if</span><span class="nf">iers</span><span class="p">()</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="p">(</span><span class="s2">"private"</span><span class="p">,</span><span class="w"> </span><span class="s2">"final"</span><span class="p">))]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Greeter</span> <span class="o">{</span> <span class="kd">public</span> <span class="kd">static</span> <span class="nc">Foo</span> <span class="n">foo</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Foo</span><span class="o">();</span> <span class="o">...</span> <span class="o">}</span> <span class="c1">// avoid this</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Greeter</span> <span class="o">{</span> <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="nc">Foo</span> <span class="no">FOO</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Foo</span><span class="o">();</span> <span class="o">...</span> <span class="o">}</span> <span class="c1">// use this instead</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/MutableStaticState"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="ncsscount">NcssCount</h2>
<p><strong>Since:</strong> PMD 6.0.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>This rule uses the NCSS (Non-Commenting Source Statements) metric to determine the number of lines
of code in a class, method or constructor. NCSS ignores comments, blank lines, and only counts actual
statements. For more details on the calculation, see the documentation
<a href="https://docs.pmd-code.org/apidocs/pmd-java/7.4.0-SNAPSHOT/net/sourceforge/pmd/lang/java/metrics/JavaMetrics.html#NCSS"><code>NCSS</code></a>.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/NcssCountRule.java">net.sourceforge.pmd.lang.java.rule.design.NcssCountRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">java.util.Collections</span><span class="o">;</span> <span class="c1">// +0</span>
<span class="kn">import</span> <span class="nn">java.io.IOException</span><span class="o">;</span> <span class="c1">// +0</span>
<span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span> <span class="c1">// +1, total Ncss = 12</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">bigMethod</span><span class="o">()</span> <span class="c1">// +1</span>
<span class="kd">throws</span> <span class="nc">IOException</span> <span class="o">{</span>
<span class="kt">int</span> <span class="n">x</span> <span class="o">=</span> <span class="mi">0</span><span class="o">,</span> <span class="n">y</span> <span class="o">=</span> <span class="mi">2</span><span class="o">;</span> <span class="c1">// +1</span>
<span class="kt">boolean</span> <span class="n">a</span> <span class="o">=</span> <span class="kc">false</span><span class="o">,</span> <span class="n">b</span> <span class="o">=</span> <span class="kc">true</span><span class="o">;</span> <span class="c1">// +1</span>
<span class="k">if</span> <span class="o">(</span><span class="n">a</span> <span class="o">||</span> <span class="n">b</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// +1</span>
<span class="k">try</span> <span class="o">{</span> <span class="c1">// +1</span>
<span class="k">do</span> <span class="o">{</span> <span class="c1">// +1</span>
<span class="n">x</span> <span class="o">+=</span> <span class="mi">2</span><span class="o">;</span> <span class="c1">// +1</span>
<span class="o">}</span> <span class="k">while</span> <span class="o">(</span><span class="n">x</span> <span class="o">&lt;</span> <span class="mi">12</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">exit</span><span class="o">(</span><span class="mi">0</span><span class="o">);</span> <span class="c1">// +1</span>
<span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="nc">IOException</span> <span class="n">ioe</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// +1</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nf">PatheticFailException</span><span class="o">(</span><span class="n">ioe</span><span class="o">);</span> <span class="c1">// +1</span>
<span class="o">}</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
<span class="k">assert</span> <span class="kc">false</span><span class="o">;</span> <span class="c1">// +1</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>methodReportLevel</td>
<td>60</td>
<td>NCSS reporting threshold for methods</td>
</tr>
<tr>
<td>classReportLevel</td>
<td>1500</td>
<td>NCSS reporting threshold for classes</td>
</tr>
<tr>
<td>ncssOptions</td>
<td> </td>
<td>Choose options for the computation of Ncss</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/NcssCount"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/NcssCount"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"methodReportLevel"</span> <span class="na">value=</span><span class="s">"60"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"classReportLevel"</span> <span class="na">value=</span><span class="s">"1500"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"ncssOptions"</span> <span class="na">value=</span><span class="s">""</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="npathcomplexity">NPathComplexity</h2>
<p><strong>Since:</strong> PMD 3.9</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>The NPath complexity of a method is the number of acyclic execution paths through that method.
While cyclomatic complexity counts the number of decision points in a method, NPath counts the number of
full paths from the beginning to the end of the block of the method. That metric grows exponentially, as
it multiplies the complexity of statements in the same block. For more details on the calculation, see the
documentation <a href="https://docs.pmd-code.org/apidocs/pmd-java/7.4.0-SNAPSHOT/net/sourceforge/pmd/lang/java/metrics/JavaMetrics.html#NPATH"><code>NPATH</code></a>.</p>
<p>A threshold of 200 is generally considered the point where measures should be taken to reduce
complexity and increase readability.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/NPathComplexityRule.java">net.sourceforge.pmd.lang.java.rule.design.NPathComplexityRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">bar</span><span class="o">()</span> <span class="o">{</span> <span class="c1">// Ncss = 252: reported!</span>
<span class="kt">boolean</span> <span class="n">a</span><span class="o">,</span> <span class="n">b</span> <span class="o">=</span> <span class="kc">true</span><span class="o">;</span>
<span class="k">try</span> <span class="o">{</span> <span class="c1">// 2 * 2 + 2 = 6</span>
<span class="k">if</span> <span class="o">(</span><span class="kc">true</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// 2</span>
<span class="nc">List</span> <span class="n">buz</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">ArrayList</span><span class="o">();</span>
<span class="o">}</span>
<span class="k">for</span><span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="mi">19</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span> <span class="c1">// * 2</span>
<span class="nc">List</span> <span class="n">buz</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">ArrayList</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span> <span class="k">catch</span><span class="o">(</span><span class="nc">Exception</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="kc">true</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// 2</span>
<span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="k">while</span> <span class="o">(</span><span class="n">j</span><span class="o">++</span> <span class="o">&lt;</span> <span class="mi">20</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// * 2</span>
<span class="nc">List</span> <span class="n">buz</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">ArrayList</span><span class="o">();</span>
<span class="o">}</span>
<span class="k">switch</span><span class="o">(</span><span class="n">j</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// * 7</span>
<span class="k">case</span> <span class="mi">1</span><span class="o">:</span>
<span class="k">case</span> <span class="mi">2</span><span class="o">:</span> <span class="k">break</span><span class="o">;</span>
<span class="k">case</span> <span class="mi">3</span><span class="o">:</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">5</span><span class="o">;</span> <span class="k">break</span><span class="o">;</span>
<span class="k">case</span> <span class="mi">4</span><span class="o">:</span> <span class="k">if</span> <span class="o">(</span><span class="n">b</span> <span class="o">&amp;&amp;</span> <span class="n">a</span><span class="o">)</span> <span class="o">{</span> <span class="n">bar</span><span class="o">();</span> <span class="o">}</span> <span class="k">break</span><span class="o">;</span>
<span class="k">default</span><span class="o">:</span> <span class="k">break</span><span class="o">;</span>
<span class="o">}</span>
<span class="k">do</span> <span class="o">{</span> <span class="c1">// * 3</span>
<span class="nc">List</span> <span class="n">buz</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">ArrayList</span><span class="o">();</span>
<span class="o">}</span> <span class="k">while</span> <span class="o">(</span><span class="n">a</span> <span class="o">&amp;&amp;</span> <span class="n">j</span><span class="o">++</span> <span class="o">&lt;</span> <span class="mi">30</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>reportLevel</td>
<td>200</td>
<td>N-Path Complexity reporting threshold</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/NPathComplexity"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/NPathComplexity"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"reportLevel"</span> <span class="na">value=</span><span class="s">"200"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="signaturedeclarethrowsexception">SignatureDeclareThrowsException</h2>
<p><strong>Since:</strong> PMD 1.2</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>A method/constructor shouldn’t explicitly throw the generic java.lang.Exception, since it
is unclear which exceptions that can be thrown from the methods. It might be
difficult to document and understand such vague interfaces. Use either a class
derived from RuntimeException or a checked exception.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/SignatureDeclareThrowsExceptionRule.java">net.sourceforge.pmd.lang.java.rule.design.SignatureDeclareThrowsExceptionRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kt">void</span> <span class="nf">foo</span><span class="o">()</span> <span class="kd">throws</span> <span class="nc">Exception</span> <span class="o">{</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>IgnoreJUnitCompletely</td>
<td>false</td>
<td>Allow all methods in a JUnit3 TestCase to throw Exceptions</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/SignatureDeclareThrowsException"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/SignatureDeclareThrowsException"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"IgnoreJUnitCompletely"</span> <span class="na">value=</span><span class="s">"false"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="simplifiedternary">SimplifiedTernary</h2>
<p><strong>Since:</strong> PMD 5.4.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Reports ternary expression with the form <code class="language-plaintext highlighter-rouge">condition ? literalBoolean : foo</code>
or <code class="language-plaintext highlighter-rouge">condition ? foo : literalBoolean</code>.</p>
<p>These expressions can be simplified as follows:</p>
<ul>
<li><code class="language-plaintext highlighter-rouge">condition ? true : expr</code> simplifies to <code class="language-plaintext highlighter-rouge">condition || expr</code></li>
<li><code class="language-plaintext highlighter-rouge">condition ? false : expr</code> simplifies to <code class="language-plaintext highlighter-rouge">!condition &amp;&amp; expr</code></li>
<li><code class="language-plaintext highlighter-rouge">condition ? expr : true</code> simplifies to <code class="language-plaintext highlighter-rouge">!condition || expr</code></li>
<li><code class="language-plaintext highlighter-rouge">condition ? expr : false</code> simplifies to <code class="language-plaintext highlighter-rouge">condition &amp;&amp; expr</code></li>
</ul>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">ConditionalExpression</span><span class="p">[</span><span class="nt">BooleanLiteral</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="ow">not</span><span class="p">(</span><span class="nt">NullLiteral</span><span class="p">)]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">test</span><span class="o">()</span> <span class="o">{</span>
<span class="k">return</span> <span class="n">condition</span> <span class="o">?</span> <span class="kc">true</span> <span class="o">:</span> <span class="n">something</span><span class="o">();</span> <span class="c1">// can be as simple as return condition || something();</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">test2</span><span class="o">()</span> <span class="o">{</span>
<span class="kd">final</span> <span class="kt">boolean</span> <span class="n">value</span> <span class="o">=</span> <span class="n">condition</span> <span class="o">?</span> <span class="kc">false</span> <span class="o">:</span> <span class="n">something</span><span class="o">();</span> <span class="c1">// can be as simple as value = !condition &amp;&amp; something();</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">test3</span><span class="o">()</span> <span class="o">{</span>
<span class="k">return</span> <span class="n">condition</span> <span class="o">?</span> <span class="n">something</span><span class="o">()</span> <span class="o">:</span> <span class="kc">true</span><span class="o">;</span> <span class="c1">// can be as simple as return !condition || something();</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">test4</span><span class="o">()</span> <span class="o">{</span>
<span class="kd">final</span> <span class="kt">boolean</span> <span class="n">otherValue</span> <span class="o">=</span> <span class="n">condition</span> <span class="o">?</span> <span class="n">something</span><span class="o">()</span> <span class="o">:</span> <span class="kc">false</span><span class="o">;</span> <span class="c1">// can be as simple as condition &amp;&amp; something();</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">test5</span><span class="o">()</span> <span class="o">{</span>
<span class="k">return</span> <span class="n">condition</span> <span class="o">?</span> <span class="kc">true</span> <span class="o">:</span> <span class="kc">false</span><span class="o">;</span> <span class="c1">// can be as simple as return condition;</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/SimplifiedTernary"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="simplifybooleanexpressions">SimplifyBooleanExpressions</h2>
<p><strong>Since:</strong> PMD 1.05</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Avoid unnecessary comparisons in boolean expressions, they serve no purpose and impacts readability.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">InfixExpression</span><span class="p">[</span><span class="na">@Operator</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="p">(</span><span class="s2">"=="</span><span class="p">,</span><span class="w"> </span><span class="s2">"!="</span><span class="p">)]</span><span class="o">/</span><span class="nt">BooleanLiteral</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Bar</span> <span class="o">{</span>
<span class="c1">// can be simplified to</span>
<span class="c1">// bar = isFoo();</span>
<span class="kd">private</span> <span class="kt">boolean</span> <span class="n">bar</span> <span class="o">=</span> <span class="o">(</span><span class="n">isFoo</span><span class="o">()</span> <span class="o">==</span> <span class="kc">true</span><span class="o">);</span>
<span class="kd">public</span> <span class="nf">isFoo</span><span class="o">()</span> <span class="o">{</span> <span class="k">return</span> <span class="kc">false</span><span class="o">;}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/SimplifyBooleanExpressions"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="simplifybooleanreturns">SimplifyBooleanReturns</h2>
<p><strong>Since:</strong> PMD 0.9</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Avoid unnecessary if-then-else statements when returning a boolean. The result of
the conditional test can be returned instead.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/SimplifyBooleanReturnsRule.java">net.sourceforge.pmd.lang.java.rule.design.SimplifyBooleanReturnsRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">isBarEqualTo</span><span class="o">(</span><span class="kt">int</span> <span class="n">x</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">bar</span> <span class="o">==</span> <span class="n">x</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// this bit of code...</span>
<span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
<span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">isBarEqualTo</span><span class="o">(</span><span class="kt">int</span> <span class="n">x</span><span class="o">)</span> <span class="o">{</span>
<span class="k">return</span> <span class="n">bar</span> <span class="o">==</span> <span class="n">x</span><span class="o">;</span> <span class="c1">// can be replaced with this</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/SimplifyBooleanReturns"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="simplifyconditional">SimplifyConditional</h2>
<p><strong>Since:</strong> PMD 3.1</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>No need to check for null before an instanceof; the instanceof keyword returns false when given a null argument.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/SimplifyConditionalRule.java">net.sourceforge.pmd.lang.java.rule.design.SimplifyConditionalRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kt">void</span> <span class="nf">bar</span><span class="o">(</span><span class="nc">Object</span> <span class="n">x</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">x</span> <span class="o">!=</span> <span class="kc">null</span> <span class="o">&amp;&amp;</span> <span class="n">x</span> <span class="k">instanceof</span> <span class="nc">Bar</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">// just drop the "x != null" check</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/SimplifyConditional"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="singularfield">SingularField</h2>
<p><strong>Since:</strong> PMD 3.1</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Reports fields which may be converted to a local variable. This is so because
in every method where the field is used, it is assigned before it is first read.
Hence, the value that the field had before the method call may not be observed,
so it might as well not be stored in the enclosing object.</p>
<p>Limitations:</p>
<ul>
<li>We can only check private fields for now.</li>
<li>The rule is not aware of threading, so it may cause false positives in concurrent code.
Such FPs are best handled by suppression (see also the <code class="language-plaintext highlighter-rouge">ignoredAnnotations</code> property).</li>
</ul>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/SingularFieldRule.java">net.sourceforge.pmd.lang.java.rule.design.SingularFieldRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">private</span> <span class="kt">int</span> <span class="n">x</span><span class="o">;</span> <span class="c1">// this will be reported</span>
<span class="kd">public</span> <span class="kt">int</span> <span class="nf">foo</span><span class="o">(</span><span class="kt">int</span> <span class="n">y</span><span class="o">)</span> <span class="o">{</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">y</span> <span class="o">+</span> <span class="mi">5</span><span class="o">;</span> <span class="c1">// assigned before any read</span>
<span class="k">return</span> <span class="n">x</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">int</span> <span class="nf">fooOk</span><span class="o">(</span><span class="kt">int</span> <span class="n">y</span><span class="o">)</span> <span class="o">{</span>
<span class="kt">int</span> <span class="n">z</span> <span class="o">=</span> <span class="n">y</span> <span class="o">+</span> <span class="mi">5</span><span class="o">;</span> <span class="c1">// might as well be a local like here</span>
<span class="k">return</span> <span class="n">z</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>ignoredAnnotations</td>
<td>java.lang.Deprecated , javafx.fxml.FXML , lombok.Getter , lombok.Setter , lombok.experimental.Delegate</td>
<td>Fully qualified names of the annotation types that should be ignored by this rule</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/SingularField"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/SingularField"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"ignoredAnnotations"</span> <span class="na">value=</span><span class="s">"java.lang.Deprecated,javafx.fxml.FXML,lombok.Getter,lombok.Setter,lombok.experimental.Delegate"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="switchdensity">SwitchDensity</h2>
<p><strong>Since:</strong> PMD 1.02</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>A high ratio of statements to labels in a switch statement implies that the switch statement
is overloaded. Consider moving the statements into new methods or creating subclasses based
on the switch variable.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/SwitchDensityRule.java">net.sourceforge.pmd.lang.java.rule.design.SwitchDensityRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Foo</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">bar</span><span class="o">(</span><span class="kt">int</span> <span class="n">x</span><span class="o">)</span> <span class="o">{</span>
<span class="k">switch</span> <span class="o">(</span><span class="n">x</span><span class="o">)</span> <span class="o">{</span>
<span class="k">case</span> <span class="mi">1</span><span class="o">:</span> <span class="o">{</span>
<span class="c1">// lots of statements</span>
<span class="k">break</span><span class="o">;</span>
<span class="o">}</span> <span class="k">case</span> <span class="mi">2</span><span class="o">:</span> <span class="o">{</span>
<span class="c1">// lots of statements</span>
<span class="k">break</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>minimum</td>
<td>10</td>
<td>Threshold above which a switch statement or expression is reported</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/SwitchDensity"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/SwitchDensity"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"minimum"</span> <span class="na">value=</span><span class="s">"10"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="toomanyfields">TooManyFields</h2>
<p><strong>Since:</strong> PMD 3.0</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Classes that have too many fields can become unwieldy and could be redesigned to have fewer fields,
possibly through grouping related fields in new objects. For example, a class with individual
city/state/zip fields could park them within a single Address field.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">ClassDeclaration</span><span class="o">/</span><span class="nt">ClassBody</span><span class="w">
</span><span class="p">[</span><span class="nf">count</span><span class="p">(</span><span class="nt">FieldDeclaration</span><span class="w">
</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="nn">pmd-java:</span><span class="ow">mod</span><span class="kr">if</span><span class="nf">iers</span><span class="p">()</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'final'</span><span class="p">)]</span><span class="w">
</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="nn">pmd-java:</span><span class="ow">mod</span><span class="kr">if</span><span class="nf">iers</span><span class="p">()</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'static'</span><span class="p">)]</span><span class="w">
</span><span class="p">)</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="nv">$maxfields</span><span class="p">]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Person</span> <span class="o">{</span> <span class="c1">// too many separate fields</span>
<span class="kt">int</span> <span class="n">birthYear</span><span class="o">;</span>
<span class="kt">int</span> <span class="n">birthMonth</span><span class="o">;</span>
<span class="kt">int</span> <span class="n">birthDate</span><span class="o">;</span>
<span class="kt">float</span> <span class="n">height</span><span class="o">;</span>
<span class="kt">float</span> <span class="n">weight</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Person</span> <span class="o">{</span> <span class="c1">// this is more manageable</span>
<span class="nc">Date</span> <span class="n">birthDate</span><span class="o">;</span>
<span class="nc">BodyMeasurements</span> <span class="n">measurements</span><span class="o">;</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>maxfields</td>
<td>15</td>
<td>Max allowable fields</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/TooManyFields"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/TooManyFields"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"maxfields"</span> <span class="na">value=</span><span class="s">"15"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="toomanymethods">TooManyMethods</h2>
<p><strong>Since:</strong> PMD 4.2</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>A class with too many methods is probably a good suspect for refactoring, in order to reduce its
complexity and find a way to have more fine grained objects.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">ClassDeclaration</span><span class="o">/</span><span class="nt">ClassBody</span><span class="w">
</span><span class="p">[</span><span class="w">
</span><span class="nf">count</span><span class="p">(</span><span class="nt">MethodDeclaration</span><span class="p">[</span><span class="w">
</span><span class="ow">not</span><span class="w"> </span><span class="p">(</span><span class="w">
</span><span class="p">(</span><span class="nf">starts-with</span><span class="p">(</span><span class="na">@Name</span><span class="p">,</span><span class="s1">'get'</span><span class="p">)</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="nf">starts-with</span><span class="p">(</span><span class="na">@Name</span><span class="p">,</span><span class="s1">'set'</span><span class="p">)</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="nf">starts-with</span><span class="p">(</span><span class="na">@Name</span><span class="p">,</span><span class="s1">'is'</span><span class="p">))</span><span class="w">
</span><span class="ow">and</span><span class="w">
</span><span class="nf">count</span><span class="p">(</span><span class="nt">Block</span><span class="err">/*</span><span class="p">)</span><span class="w"> </span><span class="err">&lt;=</span><span class="w"> </span><span class="m">1</span><span class="w">
</span><span class="p">)</span><span class="w">
</span><span class="p">])</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="nv">$maxmethods</span><span class="w">
</span><span class="p">]</span><span class="w">
</span></code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>maxmethods</td>
<td>10</td>
<td>The method count reporting threshold</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/TooManyMethods"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/TooManyMethods"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"maxmethods"</span> <span class="na">value=</span><span class="s">"10"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="uselessoverridingmethod">UselessOverridingMethod</h2>
<p><strong>Since:</strong> PMD 3.3</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>The overriding method merely calls the same method defined in a superclass.</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/UselessOverridingMethodRule.java">net.sourceforge.pmd.lang.java.rule.design.UselessOverridingMethodRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kt">void</span> <span class="nf">foo</span><span class="o">(</span><span class="nc">String</span> <span class="n">bar</span><span class="o">)</span> <span class="o">{</span>
<span class="kd">super</span><span class="o">.</span><span class="na">foo</span><span class="o">(</span><span class="n">bar</span><span class="o">);</span> <span class="c1">// why bother overriding?</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="nc">String</span> <span class="nf">foo</span><span class="o">()</span> <span class="o">{</span>
<span class="k">return</span> <span class="kd">super</span><span class="o">.</span><span class="na">foo</span><span class="o">();</span> <span class="c1">// why bother overriding?</span>
<span class="o">}</span>
<span class="nd">@Id</span>
<span class="kd">public</span> <span class="nc">Long</span> <span class="nf">getId</span><span class="o">()</span> <span class="o">{</span>
<span class="k">return</span> <span class="kd">super</span><span class="o">.</span><span class="na">getId</span><span class="o">();</span> <span class="c1">// OK if 'ignoreAnnotations' is false, which is the default behavior</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>ignoreAnnotations</td>
<td>false</td>
<td>Ignore methods that have annotations (except @Override)</td>
</tr>
</tbody>
</table>
<p><strong>Use this rule with the default properties by just referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/UselessOverridingMethod"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<p><strong>Use this rule and customize it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/UselessOverridingMethod"</span><span class="nt">&gt;</span>
<span class="nt">&lt;properties&gt;</span>
<span class="nt">&lt;property</span> <span class="na">name=</span><span class="s">"ignoreAnnotations"</span> <span class="na">value=</span><span class="s">"false"</span> <span class="nt">/&gt;</span>
<span class="nt">&lt;/properties&gt;</span>
<span class="nt">&lt;/rule&gt;</span>
</code></pre></div></div>
<h2 id="useobjectforclearerapi">UseObjectForClearerAPI</h2>
<p><strong>Since:</strong> PMD 4.2.6</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>When you write a public method, you should be thinking in terms of an API. If your method is public, it means other class
will use it, therefore, you want (or need) to offer a comprehensive and evolutive API. If you pass a lot of information
as a simple series of Strings, you may think of using an Object to represent all those information. You’ll get a simpler
API (such as doWork(Workload workload), rather than a tedious series of Strings) and more importantly, if you need at some
point to pass extra data, you’ll be able to do so by simply modifying or extending Workload without any modification to
your API.</p>
<p><strong>This rule is defined by the following XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">MethodDeclaration</span><span class="p">[</span><span class="nn">pmd-java:</span><span class="ow">mod</span><span class="kr">if</span><span class="nf">iers</span><span class="p">()</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'public'</span><span class="p">]</span><span class="w">
</span><span class="p">[</span><span class="nf">count</span><span class="p">(</span><span class="nt">FormalParameters</span><span class="o">/</span><span class="nt">FormalParameter</span><span class="p">[</span><span class="nn">pmd-java:</span><span class="nf">typeIs</span><span class="p">(</span><span class="s1">'java.lang.String'</span><span class="p">)])</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="m">3</span><span class="p">]</span><span class="w">
</span></code></pre></div></div>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">MyClass</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">connect</span><span class="o">(</span><span class="nc">String</span> <span class="n">username</span><span class="o">,</span>
<span class="nc">String</span> <span class="n">pssd</span><span class="o">,</span>
<span class="nc">String</span> <span class="n">databaseName</span><span class="o">,</span>
<span class="nc">String</span> <span class="n">databaseAdress</span><span class="o">)</span>
<span class="c1">// Instead of those parameters object</span>
<span class="c1">// would ensure a cleaner API and permit</span>
<span class="c1">// to add extra data transparently (no code change):</span>
<span class="c1">// void connect(UserData data);</span>
<span class="o">{</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/UseObjectForClearerAPI"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="useutilityclass">UseUtilityClass</h2>
<p><strong>Since:</strong> PMD 0.3</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>For classes that only have static methods, consider making them utility classes.
Note that this doesn’t apply to abstract classes, since their subclasses may
well include non-static methods. Also, if you want this class to be a utility class,
remember to add a private constructor to prevent instantiation.
(Note, that this use was known before PMD 5.1.0 as UseSingleton).</p>
<p><strong>This rule is defined by the following Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/UseUtilityClassRule.java">net.sourceforge.pmd.lang.java.rule.design.UseUtilityClassRule</a></p>
<p><strong>Example(s):</strong></p>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">MaybeAUtility</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">foo</span><span class="o">()</span> <span class="o">{}</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">bar</span><span class="o">()</span> <span class="o">{}</span>
<span class="o">}</span>
</code></pre></div></div>
<p><strong>Use this rule by referencing it:</strong></p>
<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;rule</span> <span class="na">ref=</span><span class="s">"category/java/design.xml/UseUtilityClass"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<div class="tags">
</div>
</div>
<footer>
<hr />
<div>
This documentation is written in markdown. <br />
If there is something missing or can be improved, edit this page on
github and create a PR:
<a
target="_blank"
href="https://github.com/pmd/pmd/blob/master/docs/../pmd-java/src/main/resources/category/java/design.xml"
role="button"
><i class="fab fa-github fa-lg"></i> Edit on GitHub</a
>
</div>
<hr />
<div class="row">
<div class="col-lg-12 footer">
&copy;2024 PMD Open Source Project. All rights
reserved. <br />
Site last generated: Jul 23, 2024 <br />
<p>
<img src="images/logo/pmd-logo-70px.png" alt="PMD
logo"/>
</p>
</div>
</div>
</footer>
</div>
<!-- /.row -->
</div>
<!-- /.container -->
</div>
<!-- Sticky TOC column -->
<div class="toc-col">
<div id="toc"></div>
</div>
<!-- /.toc-container-wrapper -->
</div>
</div>
<script type="application/javascript" src="assets/jquery-3.5.1/jquery-3.5.1.min.js"></script>
<script type="application/javascript" src="assets/anchorjs-4.2.2/anchor.min.js"></script>
<script type="application/javascript" src="assets/navgoco-0.2.1/src/jquery.navgoco.min.js"></script>
<script type="application/javascript" src="assets/bootstrap-4.5.2-dist/js/bootstrap.bundle.min.js"></script>
<script type="application/javascript" src="assets/Simple-Jekyll-Search-1.0.8/dest/jekyll-search.js"></script>
<script type="application/javascript" src="assets/jekyll-table-of-contents/toc.js"></script>
<script type="application/javascript" src="js/tabstate.js"></script>
<script type="application/javascript" src="js/customscripts.js"></script>
</body>
</html>
View Git Blame Copy Permalink