phoedos/pmd
1
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
pmd/pmd_rules_java_design.html
Travis CI (pmd-bot) eff825bed7 Update documentation 
TRAVIS_JOB_NUMBER=3428.2
TRAVIS_COMMIT_RANGE=be73856c7c7974d00388f9728beeefd35370aaf8...cfe07822be49311797a539a9b3cffb4de4fb512e
2019-02-08 22:12:28 +00:00

3605 lines
181 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, ClassWithOnlyPrivateConstructorsShouldBeFinal, CollapsibleIfStatements, CouplingBetweenObjects, CyclomaticComplexity, DataClass, DoNotExtendJavaLangError, ExceptionAsFlowControl, ExcessiveClassLength, ExcessiveImports, ExcessiveMethodLength, ExcessiveParameterList, ExcessivePublicCount, FinalFieldCouldBeStatic, GodClass, ImmutableField, LawOfDemeter, LogicInversion, LoosePackageCoupling, ModifiedCyclomaticComplexity, NcssConstructorCount, NcssCount, NcssMethodCount, NcssTypeCount, NPathComplexity, SignatureDeclareThrowsException, SimplifiedTernary, SimplifyBooleanAssertion, SimplifyBooleanExpressions, SimplifyBooleanReturns, SimplifyConditional, SingularField, StdCyclomaticComplexity, SwitchDensity, TooManyFields, TooManyMethods, UselessOverridingMethod, UseObjectForClearerAPI, UseUtilityClass">
<title>Design | PMD Source Code Analyzer</title>
<link rel="stylesheet" href="css/syntax.css">
<link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">
<!--<link rel="stylesheet" type="text/css" href="css/bootstrap.min.css">-->
<link rel="stylesheet" href="css/modern-business.css">
<link rel="stylesheet" href="css/lavish-bootstrap.css">
<link rel="stylesheet" href="css/customstyles.css">
<link rel="stylesheet" href="css/theme-blue.css">
<link rel="stylesheet" href="css/pmd-customstyles.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-cookie/1.4.1/jquery.cookie.min.js"></script>
<script src="js/jquery.navgoco.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/anchor-js/2.0.0/anchor.min.js"></script>
<script src="js/toc.js"></script>
<script src="js/customscripts.js"></script>
<link rel="shortcut icon" href="images/favicon.ico" type="image/x-icon">
<link rel="icon" href="images/favicon.ico" type="image/x-icon">
<!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
<!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
<!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
<script src="https://oss.maxcdn.com/libs/respond.js/1.4.2/respond.min.js"></script>
<![endif]-->
<link rel="alternate" type="application/rss+xml" title="" href="https://pmd.github.io/pmd/feed.xml">
<script>
$(document).ready(function() {
// Initialize navgoco with default options
$("#mysidebar").navgoco({
caretHtml: '',
accordion: true,
openClass: 'active', // open
save: false, // leave false or nav highlighting doesn't work right
cookie: {
name: 'navgoco',
expires: false,
path: '/'
},
slide: {
duration: 400,
easing: 'swing'
}
});
$("#collapseAll").click(function(e) {
e.preventDefault();
$("#mysidebar").navgoco('toggle', false);
});
$("#expandAll").click(function(e) {
e.preventDefault();
$("#mysidebar").navgoco('toggle', true);
});
});
</script>
<script>
$(function () {
$('[data-toggle="tooltip"]').tooltip()
})
</script>
<script>
$(document).ready(function() {
$("#tg-sb-link").click(function() {
$("#tg-sb-sidebar").toggle();
$("#tg-sb-content").toggleClass('col-md-9');
$("#tg-sb-content").toggleClass('col-md-12');
$("#tg-sb-icon").toggleClass('fa-toggle-on');
$("#tg-sb-icon").toggleClass('fa-toggle-off');
});
});
</script>
</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-inverse navbar-fixed-top">
<div class="container topnavlinks">
<div class="navbar-header">
<button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a class="fa fa-home fa-lg navbar-brand" href="index.html">&nbsp;<span class="projectTitle"> PMD Source Code Analyzer Project</span></a>
</div>
<div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
<ul class="nav navbar-nav navbar-right">
<!-- toggle sidebar button -->
<li><a id="tg-sb-link" href="#"><i id="tg-sb-icon" class="fa fa-toggle-on"></i> Nav</a></li>
<!-- entries without drop-downs appear here -->
<li><a href="https://github.com/pmd/pmd/releases/latest" target="_blank">Download</a></li>
<li><a 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.-->
<!--comment out this block if you want to hide search-->
<li>
<!--start search-->
<div id="search-demo-container">
<input type="text" id="search-input" placeholder="search...">
<ul id="results-container"></ul>
</div>
<script src="js/jekyll-search.js" type="text/javascript"></script>
<script type="text/javascript">
SimpleJekyllSearch.init({
searchInput: document.getElementById('search-input'),
resultsContainer: document.getElementById('results-container'),
dataSource: 'search.json',
searchResultTemplate: '<li><a href="{url}" title="Design">{title}</a></li>',
noResultsText: 'No results found.',
limit: 10,
fuzzy: true,
})
</script>
<!--end search-->
</li>
</ul>
</div>
</div>
<!-- /.container -->
</nav>
<!-- Page Content -->
<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 6.12.0</li>
<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_next_major_development.html">PMD 7.0.0 development</a></li>
<li><a href="pmd_about_help.html">Getting help</a></li>
</ul>
</li>
<li>
<a href="#">User Documentation</a>
<ul>
<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 class="subfolders">
<a href="#">Extending PMD</a>
<ul>
<li><a href="pmd_userdocs_extending_writing_pmd_rules.html">Writing a rule</a></li>
<li><a href="pmd_userdocs_extending_writing_xpath_rules.html">Writing XPath rules</a></li>
<li><a href="pmd_userdocs_extending_defining_properties.html">Defining rule properties</a></li>
<li><a href="pmd_userdocs_extending_metrics_howto.html">Using and defining code metrics</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>
</ul>
</li>
<li><a href="pmd_userdocs_cpd.html">Copy-paste detection</a></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_ant.html">Ant</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="#">Ecmascript 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="#">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="#">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="#">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_vf.html">Index</a></li>
<li><a href="pmd_rules_vf_security.html">Security</a></li>
</ul>
</li>
<li class="subfolders">
<a href="#">VM Rules</a>
<ul>
<li><a href="pmd_rules_vm.html">Index</a></li>
<li><a href="pmd_rules_vm_bestpractices.html">Best Practices</a></li>
<li><a href="pmd_rules_vm_design.html">Design</a></li>
<li><a href="pmd_rules_vm_errorprone.html">Error Prone</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_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_jsp.html">JSP Support</a></li>
<li><a href="pmd_java_metrics_index.html">Java code metrics</a></li>
<li><a href="pmd_apex_metrics_index.html">Apex code metrics</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 class="subfolders">
<a href="#">Major contributions</a>
<ul>
<li><a href="pmd_devdocs_major_adding_new_language.html">Adding a new language</a></li>
<li><a href="pmd_devdocs_major_adding_new_cpd_language.html">Adding a new CPD language</a></li>
<li><a href="pmd_devdocs_major_adding_new_metrics_framework.html">Adding metrics support to a language</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_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 class="subfolders">
<a href="#">Project management</a>
<ul>
<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>
</ul>
</li>
</ul>
</li>
<!-- if you aren't using the accordion, uncomment this block:
<p class="external">
<a href="#" id="collapseAll">Collapse All</a> | <a href="#" id="expandAll">Expand All</a>
</p>
-->
</ul>
<!-- this highlights the active parent class in the navgoco sidebar. this is critical so that the parent expands when you're viewing a page. This must appear below the sidebar code above. Otherwise, if placed inside customscripts.js, the script runs before the sidebar code runs and the class never gets inserted.-->
<script>$("li.active").parents('li').toggleClass("active");</script>
</div>
<!-- Content Column -->
<div class="col-md-9" id="tg-sb-content">
<div class="post-header">
<h1 class="post-title-main">Design</h1>
</div>
<div class="post-content">
<div class="summary">Rules that help you discover design issues.</div>
<!-- this handles the automatic toc. use ## for subheads to auto-generate the on-page minitoc. if you use html tags, you must supply an ID for the heading element in order for it to appear in the minitoc. -->
<script>
$( document ).ready(function() {
// Handler for .ready() called.
$('#toc').toc({ minimumHeaders: 0, listType: 'ul', showSpeed: 0, headers: 'h2,h3,h4' });
});
</script>
<div id="toc"></div>
<a target="_blank" href="https://github.com/pmd/pmd/blob/master/docs/../pmd-java/src/main/resources/category/java/design.xml" class="btn btn-default githubEditButton" role="button"><i class="fa fa-github fa-lg"></i> Edit me</a>
<!-- 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 provides 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">ClassOrInterfaceDeclaration</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="s1">'true'</span><span class="p">]</span><span class="w">
</span><span class="p">[</span><span class="nf">count</span><span class="p">(</span><span class="o">//</span><span class="nt">MethodDeclaration</span><span class="p">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="nf">count</span><span class="p">(</span><span class="o">//</span><span class="nt">ConstructorDeclaration</span><span class="p">)</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="m">0</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="o">/</span><span class="nt">MarkerAnnotation</span><span class="o">/</span><span class="nt">Name</span><span class="p">[</span><span class="nn">pmd-java:</span><span class="nf">typeIs</span><span class="p">(</span><span class="s1">'com.google.auto.value.AutoValue'</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="n">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">CatchStatement</span><span class="o">/</span><span class="nt">FormalParameter</span><span class="o">/</span><span class="nt">Type</span><span class="o">/</span><span class="nt">ReferenceType</span><span class="o">/</span><span class="nt">ClassOrInterfaceType</span><span class="p">[</span><span class="w">
</span><span class="na">@Image</span><span class="err">=</span><span class="s1">'NullPointerException'</span><span class="w"> </span><span class="ow">or</span><span class="w">
</span><span class="na">@Image</span><span class="err">=</span><span class="s1">'Exception'</span><span class="w"> </span><span class="ow">or</span><span class="w">
</span><span class="na">@Image</span><span class="err">=</span><span class="s1">'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="n">com</span><span class="o">.</span><span class="na">igate</span><span class="o">.</span><span class="na">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="n">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="n">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="n">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="n">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>problemDepth</td>
<td>3</td>
<td>The if statement depth reporting threshold</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/AvoidDeeplyNestedIfStmts"</span> <span class="nt">/&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">CatchStatement</span><span class="p">[</span><span class="nt">FormalParameter</span><span class="w">
</span><span class="o">/</span><span class="nt">VariableDeclaratorId</span><span class="err">/</span><span class="na">@Image</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">BlockStatement</span><span class="o">/</span><span class="nt">Statement</span><span class="w">
</span><span class="o">/</span><span class="nt">ThrowStatement</span><span class="o">/</span><span class="nt">Expression</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="p">[</span><span class="nf">count</span><span class="p">(</span><span class="nt">PrimarySuffix</span><span class="p">)</span><span class="err">=</span><span class="m">0</span><span class="p">]</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="o">/</span><span class="nt">Name</span><span class="err">/</span><span class="na">@Image</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="o">/</span><span class="nt">BlockStatement</span><span class="o">/</span><span class="nt">Statement</span><span class="p">)</span><span class="w"> </span><span class="err">=</span><span class="m">1</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="n">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">CatchStatement</span><span class="p">[</span><span class="w">
</span><span class="nf">count</span><span class="p">(</span><span class="nt">Block</span><span class="o">/</span><span class="nt">BlockStatement</span><span class="o">/</span><span class="nt">Statement</span><span class="p">)</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="m">1</span><span class="w">
</span><span class="ow">and</span><span class="w">
</span><span class="nt">FormalParameter</span><span class="o">/</span><span class="nt">Type</span><span class="o">/</span><span class="nt">ReferenceType</span><span class="o">/</span><span class="nt">ClassOrInterfaceType</span><span class="err">/</span><span class="na">@Image</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">BlockStatement</span><span class="o">/</span><span class="nt">Statement</span><span class="o">/</span><span class="nt">ThrowStatement</span><span class="o">/</span><span class="nt">Expression</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="o">/</span><span class="nt">AllocationExpression</span><span class="o">/</span><span class="nt">ClassOrInterfaceType</span><span class="err">/</span><span class="na">@Image</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="o">/</span><span class="nt">BlockStatement</span><span class="o">/</span><span class="nt">Statement</span><span class="o">/</span><span class="nt">ThrowStatement</span><span class="o">/</span><span class="nt">Expression</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="o">/</span><span class="nt">AllocationExpression</span><span class="o">/</span><span class="nt">Arguments</span><span class="o">/</span><span class="nt">ArgumentList</span><span class="o">/</span><span class="nt">Expression</span><span class="p">)</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="m">1</span><span class="w">
</span><span class="ow">and</span><span class="w">
</span><span class="nt">FormalParameter</span><span class="o">/</span><span class="nt">VariableDeclaratorId</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">BlockStatement</span><span class="o">/</span><span class="nt">Statement</span><span class="o">/</span><span class="nt">ThrowStatement</span><span class="o">/</span><span class="nt">Expression</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="o">/</span><span class="nt">AllocationExpression</span><span class="o">/</span><span class="nt">Arguments</span><span class="o">/</span><span class="nt">ArgumentList</span><span class="o">/</span><span class="nt">Expression</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="o">/</span><span class="nt">Name</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="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="n">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="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="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 XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">AllocationExpression</span><span class="o">/</span><span class="nt">ClassOrInterfaceType</span><span class="p">[</span><span class="na">@Image</span><span class="err">=</span><span class="s1">'NullPointerException'</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="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">AllocationExpression</span><span class="w">
</span><span class="o">/</span><span class="nt">ClassOrInterfaceType</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="n">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="classwithonlyprivateconstructorsshouldbefinal">ClassWithOnlyPrivateConstructorsShouldBeFinal</h2>
<p><strong>Since:</strong> PMD 4.1</p>
<p><strong>Priority:</strong> High (1)</p>
<p>A class with only private constructors should be final, unless the private constructor
is invoked by a inner class.</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="nt">TypeDeclaration</span><span class="p">[</span><span class="nf">count</span><span class="p">(..</span><span class="o">/</span><span class="nt">TypeDeclaration</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">ClassOrInterfaceDeclaration</span><span class="w">
</span><span class="p">[</span><span class="na">@Final</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'false'</span><span class="p">]</span><span class="w">
</span><span class="p">[</span><span class="nf">count</span><span class="p">(.</span><span class="o">/</span><span class="nt">ClassOrInterfaceBody</span><span class="o">/</span><span class="nt">ClassOrInterfaceBodyDeclaration</span><span class="o">/</span><span class="nt">ConstructorDeclaration</span><span class="p">[</span><span class="na">@Private</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'true'</span><span class="p">])</span><span class="w"> </span><span class="o">&gt;=</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="nf">count</span><span class="p">(.</span><span class="o">/</span><span class="nt">ClassOrInterfaceBody</span><span class="o">/</span><span class="nt">ClassOrInterfaceBodyDeclaration</span><span class="o">/</span><span class="nt">ConstructorDeclaration</span><span class="p">[(</span><span class="na">@Public</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'true'</span><span class="p">)</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="p">(</span><span class="na">@Protected</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'true'</span><span class="p">)</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="p">(</span><span class="na">@PackagePrivate</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'true'</span><span class="p">)])</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="m">0</span><span class="w"> </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">ClassOrInterfaceDeclaration</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="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="collapsibleifstatements">CollapsibleIfStatements</h2>
<p><strong>Since:</strong> PMD 3.1</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Sometimes two consecutive ‘if’ statements can be consolidated by separating their conditions with a boolean short-circuit 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">IfStatement</span><span class="p">[</span><span class="na">@Else</span><span class="err">=</span><span class="s1">'false'</span><span class="p">]</span><span class="o">/</span><span class="nt">Statement</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="err">=</span><span class="s1">'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="err">=</span><span class="s1">'false'</span><span class="p">]</span><span class="o">/</span><span class="nt">Statement</span><span class="w">
</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="nt">BlockStatement</span><span class="p">)</span><span class="err">=</span><span class="m">1</span><span class="p">]</span><span class="o">/</span><span class="nt">BlockStatement</span><span class="w">
</span><span class="o">/</span><span class="nt">Statement</span><span class="o">/</span><span class="nt">IfStatement</span><span class="p">[</span><span class="na">@Else</span><span class="err">=</span><span class="s1">'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="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">// optimized implementation</span>
<span class="c1">// do 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/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="n">Blah</span> <span class="n">var1</span><span class="o">;</span>
<span class="kd">private</span> <span class="n">Bar</span> <span class="n">var2</span><span class="o">;</span>
<span class="c1">//followed by many imports of unique objects</span>
<span class="kt">void</span> <span class="n">ObjectC</span> <span class="nf">doWork</span><span class="o">()</span> <span class="o">{</span>
<span class="n">Bardo</span> <span class="n">var55</span><span class="o">;</span>
<span class="n">ObjectA</span> <span class="n">var44</span><span class="o">;</span>
<span class="n">ObjectZ</span> <span class="n">var93</span><span class="o">;</span>
<span class="k">return</span> <span class="n">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>threshold</td>
<td>20</td>
<td>Unique type reporting threshold</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/CouplingBetweenObjects"</span> <span class="nt">/&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="highlighter-rouge">if</code>, <code class="highlighter-rouge">while</code>, <code class="highlighter-rouge">for</code>, and <code class="highlighter-rouge">case</code>. For more
details on the calculation, see the documentation of the <a href="pmd_java_metrics_index.html#cyclomatic-complexity-cyclo">Cyclo metric</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.
Additionnally, 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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>classReportLevel</td>
<td>80</td>
<td>Total class complexity reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>methodReportLevel</td>
<td>10</td>
<td>Cyclomatic complexity reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>cycloOptions</td>
<td> </td>
<td>Choose options for the computation of Cyclo</td>
<td>yes. Delimiter is ‘|’.</td>
</tr>
<tr>
<td>reportLevel</td>
<td>10</td>
<td><span style="border-radius: 0.25em; color: #fff; padding: 0.2em 0.6em 0.3em; display: inline; background-color: #d9534f; font-size: 75%;">Deprecated</span> Cyclomatic Complexity reporting threshold</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/CyclomaticComplexity"</span> <span class="nt">/&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><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="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="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">ClassOrInterfaceDeclaration</span><span class="o">/</span><span class="nt">ExtendsList</span><span class="o">/</span><span class="nt">ClassOrInterfaceType</span><span class="w">
</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="n">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>Using Exceptions as form of flow control is not recommended as they obscure true exceptions when debugging.
Either 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="n">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="n">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="excessiveclasslength">ExcessiveClassLength</h2>
<p><strong>Since:</strong> PMD 0.6</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Excessive class file lengths are usually indications that the class may be burdened with excessive
responsibilities that could be provided by external classes or functions. In breaking these methods
apart the code becomes more manageable and ripe for reuse.</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/ExcessiveClassLengthRule.java">net.sourceforge.pmd.lang.java.rule.design.ExcessiveClassLengthRule</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">bar1</span><span class="o">()</span> <span class="o">{</span>
<span class="c1">// 1000 lines of code</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">bar2</span><span class="o">()</span> <span class="o">{</span>
<span class="c1">// 1000 lines of code</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">bar3</span><span class="o">()</span> <span class="o">{</span>
<span class="c1">// 1000 lines of code</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">barN</span><span class="o">()</span> <span class="o">{</span>
<span class="c1">// 1000 lines of code</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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>topscore</td>
<td> </td>
<td>Top score value</td>
<td>no</td>
</tr>
<tr>
<td>minimum</td>
<td> </td>
<td>Minimum reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>sigma</td>
<td> </td>
<td>Sigma value</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/ExcessiveClassLength"</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">// 18 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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>topscore</td>
<td> </td>
<td>Top score value</td>
<td>no</td>
</tr>
<tr>
<td>minimum</td>
<td> </td>
<td>Minimum reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>sigma</td>
<td> </td>
<td>Sigma value</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/ExcessiveImports"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="excessivemethodlength">ExcessiveMethodLength</h2>
<p><strong>Since:</strong> PMD 0.6</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>When methods are excessively long this usually indicates that the method is doing more than its
name/signature might suggest. They also become challenging for others to digest since excessive
scrolling causes readers to lose focus.
Try to reduce the method length by creating helper methods and removing any copy/pasted 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/ExcessiveMethodLengthRule.java">net.sourceforge.pmd.lang.java.rule.design.ExcessiveMethodLengthRule</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">doSomething</span><span class="o">()</span> <span class="o">{</span>
<span class="n">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">"Hello world!"</span><span class="o">);</span>
<span class="n">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">"Hello world!"</span><span class="o">);</span>
<span class="c1">// 98 copies omitted for brevity.</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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>topscore</td>
<td> </td>
<td>Top score value</td>
<td>no</td>
</tr>
<tr>
<td>minimum</td>
<td> </td>
<td>Minimum reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>sigma</td>
<td> </td>
<td>Sigma value</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/ExcessiveMethodLength"</span> <span class="nt">/&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="n">Date</span> <span class="n">birthdate</span><span class="o">,</span> <span class="n">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>topscore</td>
<td> </td>
<td>Top score value</td>
<td>no</td>
</tr>
<tr>
<td>minimum</td>
<td> </td>
<td>Minimum reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>sigma</td>
<td> </td>
<td>Sigma value</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/ExcessiveParameterList"</span> <span class="nt">/&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="n">String</span> <span class="n">value</span><span class="o">;</span>
<span class="kd">public</span> <span class="n">Bar</span> <span class="n">something</span><span class="o">;</span>
<span class="kd">public</span> <span class="n">Variable</span> <span class="n">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>topscore</td>
<td> </td>
<td>Top score value</td>
<td>no</td>
</tr>
<tr>
<td>minimum</td>
<td> </td>
<td>Minimum reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>sigma</td>
<td> </td>
<td>Sigma value</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/ExcessivePublicCount"</span> <span class="nt">/&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="na">@Final</span><span class="err">=</span><span class="s1">'true'</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="na">@Static</span><span class="err">=</span><span class="s1">'false'</span><span class="p">]</span><span class="w">
</span><span class="o">/</span><span class="nt">VariableDeclarator</span><span class="o">/</span><span class="nt">VariableInitializer</span><span class="o">/</span><span class="nt">Expression</span><span class="w">
</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="nt">PrimarySuffix</span><span class="p">)]</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="o">/</span><span class="nt">Literal</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="n">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>See also the references:</p>
<p>Michele Lanza and Radu Marinescu. Object-Oriented Metrics in Practice:
Using Software Metrics to Characterize, Evaluate, and Improve the Design
of Object-Oriented Systems. 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>Identifies private fields whose values never change once object initialization ends either in the declaration
of the field or by a constructor. This helps in converting existing classes to becoming immutable ones.</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>This rule has the following properties:</strong></p>
<table>
<thead>
<tr>
<th>Name</th>
<th>Default Value</th>
<th>Description</th>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>ignoredAnnotations</td>
<td>lombok.Setter | lombok.Getter | lombok.Builder | lombok.Data | lombok.RequiredArgsConstructor | lombok.AllArgsConstructor | lombok.Value | lombok.NoArgsConstructor</td>
<td>Fully qualified names of the annotation types that should be ignored by this rule</td>
<td>yes. Delimiter is ‘|’.</td>
</tr>
</tbody>
</table>
<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="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 helps to reduce coupling between classes
or objects.</p>
<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 two violations.
*/</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">example</span><span class="o">(</span><span class="n">Bar</span> <span class="n">b</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">// this method call is ok, as b is a parameter of "example"</span>
<span class="n">C</span> <span class="n">c</span> <span class="o">=</span> <span class="n">b</span><span class="o">.</span><span class="na">getC</span><span class="o">();</span>
<span class="c1">// this method call is a violation, as we are using c, which we got from B.</span>
<span class="c1">// We should ask b directly instead, e.g. "b.doItOnC();"</span>
<span class="n">c</span><span class="o">.</span><span class="na">doIt</span><span class="o">();</span>
<span class="c1">// this is also a violation, just expressed differently as a method chain without temporary variables.</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">// a constructor call, not a method call.</span>
<span class="n">D</span> <span class="n">d</span> <span class="o">=</span> <span class="k">new</span> <span class="n">D</span><span class="o">();</span>
<span class="c1">// this method call is ok, because we have create the new 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>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/LawOfDemeter"</span> <span class="nt">/&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">UnaryExpressionNotPlusMinus</span><span class="p">[</span><span class="na">@Image</span><span class="err">=</span><span class="s1">'!'</span><span class="p">]</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="o">/</span><span class="nt">Expression</span><span class="p">[</span><span class="nt">EqualityExpression</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="nt">RelationalExpression</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="n">some</span><span class="o">.</span><span class="na">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="n">DontUseThisClass</span> <span class="n">boo</span> <span class="o">=</span> <span class="k">new</span> <span class="n">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>packages</td>
<td> </td>
<td>Restricted packages</td>
<td>yes. Delimiter is ‘,’.</td>
</tr>
<tr>
<td>classes</td>
<td> </td>
<td>Allowed classes</td>
<td>yes. Delimiter is ‘,’.</td>
</tr>
</tbody>
</table>
<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/LoosePackageCoupling"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="modifiedcyclomaticcomplexity">ModifiedCyclomaticComplexity</h2>
<p><span style="border-radius: 0.25em; color: #fff; padding: 0.2em 0.6em 0.3em; display: inline; background-color: #d9534f;">Deprecated</span></p>
<p><strong>Since:</strong> PMD 5.1.2</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Complexity directly affects maintenance costs is determined by the number of decision points in a method
plus one for the method entry. The decision points include ‘if’, ‘while’, ‘for’, and ‘case labels’ calls.<br />
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. Modified complexity treats switch statements as a single
decision point.</p>
<p>This rule is deprecated and will be removed with PMD 7.0.0. The rule is replaced
by the rule <a href="pmd_rules_java_design.html#cyclomaticcomplexity"><code class="highlighter-rouge">CyclomaticComplexity</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/ModifiedCyclomaticComplexityRule.java">net.sourceforge.pmd.lang.java.rule.design.ModifiedCyclomaticComplexityRule</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">// This has a Cyclomatic Complexity = 9</span>
<span class="mi">1</span> <span class="kd">public</span> <span class="kt">void</span> <span class="nf">example</span><span class="o">()</span> <span class="o">{</span>
<span class="mi">2</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="mi">3</span> <span class="k">if</span> <span class="o">(</span><span class="n">a1</span> <span class="o">==</span> <span class="n">b1</span><span class="o">)</span> <span class="o">{</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="mi">4</span> <span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="n">a2</span> <span class="o">==</span> <span class="n">b2</span><span class="o">)</span> <span class="o">{</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="o">}</span>
<span class="mi">5</span> <span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">c</span> <span class="o">==</span> <span class="n">d</span><span class="o">)</span> <span class="o">{</span>
<span class="mi">6</span> <span class="k">while</span> <span class="o">(</span><span class="n">c</span> <span class="o">==</span> <span class="n">d</span><span class="o">)</span> <span class="o">{</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="o">}</span>
<span class="mi">7</span> <span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">e</span> <span class="o">==</span> <span class="n">f</span><span class="o">)</span> <span class="o">{</span>
<span class="mi">8</span> <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">n</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="n">h</span><span class="o">;</span> <span class="n">n</span><span class="o">++)</span> <span class="o">{</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span> <span class="k">else</span><span class="o">{</span>
<span class="mi">9</span> <span class="k">switch</span> <span class="o">(</span><span class="n">z</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="n">fiddle</span><span class="o">();</span>
<span class="k">break</span><span class="o">;</span>
<span class="k">case</span> <span class="mi">2</span><span class="o">:</span>
<span class="n">fiddle</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">fiddle</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="n">fiddle</span><span class="o">();</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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>showMethodsComplexity</td>
<td>true</td>
<td>Add method average violations to the report</td>
<td>no</td>
</tr>
<tr>
<td>showClassesComplexity</td>
<td>true</td>
<td>Add class average violations to the report</td>
<td>no</td>
</tr>
<tr>
<td>reportLevel</td>
<td>10</td>
<td>Cyclomatic Complexity reporting threshold</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/ModifiedCyclomaticComplexity"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="ncssconstructorcount">NcssConstructorCount</h2>
<p><span style="border-radius: 0.25em; color: #fff; padding: 0.2em 0.6em 0.3em; display: inline; background-color: #d9534f;">Deprecated</span></p>
<p><strong>Since:</strong> PMD 3.9</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>This rule uses the NCSS (Non-Commenting Source Statements) algorithm to determine the number of lines
of code for a given constructor. NCSS ignores comments, and counts actual statements. Using this algorithm,
lines of code that are split are counted as one.</p>
<p>This rule is deprecated and will be removed with PMD 7.0.0. The rule is replaced
by the rule <a href="pmd_rules_java_design.html#ncsscount"><code class="highlighter-rouge">NcssCount</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/NcssConstructorCountRule.java">net.sourceforge.pmd.lang.java.rule.design.NcssConstructorCountRule</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="kd">extends</span> <span class="n">Bar</span> <span class="o">{</span>
<span class="kd">public</span> <span class="nf">Foo</span><span class="o">()</span> <span class="o">{</span>
<span class="kd">super</span><span class="o">();</span>
<span class="c1">//this constructor only has 1 NCSS lines</span>
<span class="kd">super</span><span class="o">.</span><span class="na">foo</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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>topscore</td>
<td> </td>
<td>Top score value</td>
<td>no</td>
</tr>
<tr>
<td>minimum</td>
<td> </td>
<td>Minimum reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>sigma</td>
<td> </td>
<td>Sigma value</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/NcssConstructorCount"</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 of
the <a href="/pmd_java_metrics_index.html#non-commenting-source-statements-ncss">NCSS metric</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="n">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="n">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="n">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>methodReportLevel</td>
<td>60</td>
<td>NCSS reporting threshold for methods</td>
<td>no</td>
</tr>
<tr>
<td>classReportLevel</td>
<td>1500</td>
<td>NCSS reporting threshold for classes</td>
<td>no</td>
</tr>
<tr>
<td>ncssOptions</td>
<td> </td>
<td>Choose options for the computation of Ncss</td>
<td>yes. Delimiter is ‘|’.</td>
</tr>
</tbody>
</table>
<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/NcssCount"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="ncssmethodcount">NcssMethodCount</h2>
<p><span style="border-radius: 0.25em; color: #fff; padding: 0.2em 0.6em 0.3em; display: inline; background-color: #d9534f;">Deprecated</span></p>
<p><strong>Since:</strong> PMD 3.9</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>This rule uses the NCSS (Non-Commenting Source Statements) algorithm to determine the number of lines
of code for a given method. NCSS ignores comments, and counts actual statements. Using this algorithm,
lines of code that are split are counted as one.</p>
<p>This rule is deprecated and will be removed with PMD 7.0.0. The rule is replaced
by the rule <a href="pmd_rules_java_design.html#ncsscount"><code class="highlighter-rouge">NcssCount</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/NcssMethodCountRule.java">net.sourceforge.pmd.lang.java.rule.design.NcssMethodCountRule</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="kd">extends</span> <span class="n">Bar</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">int</span> <span class="nf">methd</span><span class="o">()</span> <span class="o">{</span>
<span class="kd">super</span><span class="o">.</span><span class="na">methd</span><span class="o">();</span>
<span class="c1">//this method only has 1 NCSS lines</span>
<span class="k">return</span> <span class="mi">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>topscore</td>
<td> </td>
<td>Top score value</td>
<td>no</td>
</tr>
<tr>
<td>minimum</td>
<td> </td>
<td>Minimum reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>sigma</td>
<td> </td>
<td>Sigma value</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/NcssMethodCount"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="ncsstypecount">NcssTypeCount</h2>
<p><span style="border-radius: 0.25em; color: #fff; padding: 0.2em 0.6em 0.3em; display: inline; background-color: #d9534f;">Deprecated</span></p>
<p><strong>Since:</strong> PMD 3.9</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>This rule uses the NCSS (Non-Commenting Source Statements) algorithm to determine the number of lines
of code for a given type. NCSS ignores comments, and counts actual statements. Using this algorithm,
lines of code that are split are counted as one.</p>
<p>This rule is deprecated and will be removed with PMD 7.0.0. The rule is replaced
by the rule <a href="pmd_rules_java_design.html#ncsscount"><code class="highlighter-rouge">NcssCount</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/NcssTypeCountRule.java">net.sourceforge.pmd.lang.java.rule.design.NcssTypeCountRule</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="kd">extends</span> <span class="n">Bar</span> <span class="o">{</span>
<span class="kd">public</span> <span class="nf">Foo</span><span class="o">()</span> <span class="o">{</span>
<span class="c1">//this class only has 6 NCSS lines</span>
<span class="kd">super</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="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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>topscore</td>
<td> </td>
<td>Top score value</td>
<td>no</td>
</tr>
<tr>
<td>minimum</td>
<td> </td>
<td>Minimum reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>sigma</td>
<td> </td>
<td>Sigma value</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/NcssTypeCount"</span> <span class="nt">/&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 of the <a href="/pmd_java_metrics_index.html#npath-complexity-npath">NPath metric</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="n">List</span> <span class="n">buz</span> <span class="o">=</span> <span class="k">new</span> <span class="n">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="n">List</span> <span class="n">buz</span> <span class="o">=</span> <span class="k">new</span> <span class="n">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="n">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="n">List</span> <span class="n">buz</span> <span class="o">=</span> <span class="k">new</span> <span class="n">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="n">List</span> <span class="n">buz</span> <span class="o">=</span> <span class="k">new</span> <span class="n">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>reportLevel</td>
<td>200</td>
<td>N-Path Complexity reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>minimum</td>
<td>200.0</td>
<td><span style="border-radius: 0.25em; color: #fff; padding: 0.2em 0.6em 0.3em; display: inline; background-color: #d9534f; font-size: 75%;">Deprecated</span> Minimum reporting threshold</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/NPathComplexity"</span> <span class="nt">/&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="n">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>IgnoreJUnitCompletely</td>
<td>false</td>
<td>Allow all methods in a JUnit testcase to throw Exceptions</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/SignatureDeclareThrowsException"</span> <span class="nt">/&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>Look for ternary operators with the form <code class="highlighter-rouge">condition ? literalBoolean : foo</code>
or <code class="highlighter-rouge">condition ? foo : literalBoolean</code>.</p>
<p>These expressions can be simplified respectively to
<code class="highlighter-rouge">condition || foo</code> when the literalBoolean is true
<code class="highlighter-rouge">!condition &amp;&amp; foo</code> when the literalBoolean is false
or
<code class="highlighter-rouge">!condition || foo</code> when the literalBoolean is true
<code class="highlighter-rouge">condition &amp;&amp; foo</code> when the literalBoolean is false</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">ConditionalExpression</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="nt">PrimaryExpression</span><span class="err">/*</span><span class="o">/</span><span class="nt">Literal</span><span class="p">)</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="p">(</span><span class="nt">Expression</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="err">/*</span><span class="o">/</span><span class="nt">Literal</span><span class="o">/</span><span class="nt">BooleanLiteral</span><span class="p">)]</span><span class="w">
</span><span class="p">|</span><span class="w">
</span><span class="o">//</span><span class="nt">ConditionalExpression</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="nt">Expression</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="err">/*</span><span class="o">/</span><span class="nt">Literal</span><span class="p">)</span><span class="w"> </span><span class="ow">and</span><span class="w"> </span><span class="p">(</span><span class="nt">PrimaryExpression</span><span class="err">/*</span><span class="o">/</span><span class="nt">Literal</span><span class="o">/</span><span class="nt">BooleanLiteral</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="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="simplifybooleanassertion">SimplifyBooleanAssertion</h2>
<p><strong>Since:</strong> PMD 3.6</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Avoid negation in an assertTrue or assertFalse test.</p>
<p>For example, rephrase:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>assertTrue(!expr);
</code></pre></div></div>
<p>as:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>assertFalse(expr);
</code></pre></div></div>
<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">StatementExpression</span><span class="w">
</span><span class="p">[</span><span class="w">
</span><span class="p">.</span><span class="o">//</span><span class="nt">Name</span><span class="p">[</span><span class="na">@Image</span><span class="err">=</span><span class="s1">'assertTrue'</span><span class="w"> </span><span class="ow">or</span><span class="w"> </span><span class="na">@Image</span><span class="err">=</span><span class="s1">'assertFalse'</span><span class="p">]</span><span class="w">
</span><span class="ow">and</span><span class="w">
</span><span class="nt">PrimaryExpression</span><span class="o">/</span><span class="nt">PrimarySuffix</span><span class="o">/</span><span class="nt">Arguments</span><span class="o">/</span><span class="nt">ArgumentList</span><span class="w">
</span><span class="o">/</span><span class="nt">Expression</span><span class="o">/</span><span class="nt">UnaryExpressionNotPlusMinus</span><span class="p">[</span><span class="na">@Image</span><span class="err">=</span><span class="s1">'!'</span><span class="p">]</span><span class="w">
</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="w">
</span><span class="p">]</span><span class="w">
</span><span class="p">[</span><span class="kn">ancestor::</span><span class="nt">ClassOrInterfaceDeclaration</span><span class="p">[</span><span class="o">//</span><span class="nt">ClassOrInterfaceType</span><span class="p">[</span><span class="nn">pmd-java:</span><span class="nf">typeIs</span><span class="p">(</span><span class="s1">'junit.framework.TestCase'</span><span class="p">)]</span><span class="w">
</span><span class="ow">or</span><span class="w"> </span><span class="o">//</span><span class="nt">MarkerAnnotation</span><span class="o">/</span><span class="nt">Name</span><span class="p">[</span><span class="w">
</span><span class="nn">pmd-java:</span><span class="nf">typeIs</span><span class="p">(</span><span class="s1">'org.junit.Test'</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">typeIs</span><span class="p">(</span><span class="s1">'org.junit.jupiter.api.Test'</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">typeIs</span><span class="p">(</span><span class="s1">'org.junit.jupiter.api.RepeatedTest'</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">typeIs</span><span class="p">(</span><span class="s1">'org.junit.jupiter.api.TestFactory'</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">typeIs</span><span class="p">(</span><span class="s1">'org.junit.jupiter.api.TestTemplate'</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">typeIs</span><span class="p">(</span><span class="s1">'org.junit.jupiter.params.ParameterizedTest'</span><span class="p">)</span><span class="w">
</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">SimpleTest</span> <span class="kd">extends</span> <span class="n">TestCase</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">testX</span><span class="o">()</span> <span class="o">{</span>
<span class="n">assertTrue</span><span class="o">(</span><span class="s">"not empty"</span><span class="o">,</span> <span class="o">!</span><span class="n">r</span><span class="o">.</span><span class="na">isEmpty</span><span class="o">());</span> <span class="c1">// replace with assertFalse("not empty", r.isEmpty())</span>
<span class="n">assertFalse</span><span class="o">(!</span><span class="n">r</span><span class="o">.</span><span class="na">isEmpty</span><span class="o">());</span> <span class="c1">// replace with assertTrue(r.isEmpty())</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/SimplifyBooleanAssertion"</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">EqualityExpression</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="w">
</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="o">/</span><span class="nt">Literal</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 XPath expression:</strong></p>
<div class="language-xpath highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="o">//</span><span class="nt">Expression</span><span class="w">
</span><span class="p">[</span><span class="nt">ConditionalOrExpression</span><span class="w">
</span><span class="p">[</span><span class="nt">EqualityExpression</span><span class="p">[</span><span class="na">@Image</span><span class="err">=</span><span class="s1">'=='</span><span class="p">]</span><span class="w">
</span><span class="o">//</span><span class="nt">NullLiteral</span><span class="w">
</span><span class="ow">and</span><span class="w">
</span><span class="nt">UnaryExpressionNotPlusMinus</span><span class="w">
</span><span class="p">[</span><span class="na">@Image</span><span class="err">=</span><span class="s1">'!'</span><span class="p">]</span><span class="o">//</span><span class="nt">InstanceOfExpression</span><span class="p">[</span><span class="nt">PrimaryExpression</span><span class="w">
</span><span class="o">//</span><span class="nt">Name</span><span class="err">/</span><span class="na">@Image</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="kn">ancestor::</span><span class="nt">ConditionalOrExpression</span><span class="o">/</span><span class="nt">EqualityExpression</span><span class="w">
</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="o">/</span><span class="nt">Name</span><span class="err">/</span><span class="na">@Image</span><span class="p">]</span><span class="w">
</span><span class="ow">and</span><span class="w">
</span><span class="p">(</span><span class="nf">count</span><span class="p">(</span><span class="nt">UnaryExpressionNotPlusMinus</span><span class="p">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="m">1</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nf">count</span><span class="p">(</span><span class="err">*</span><span class="p">))</span><span class="w">
</span><span class="p">]</span><span class="w">
</span><span class="ow">or</span><span class="w">
</span><span class="nt">ConditionalAndExpression</span><span class="w">
</span><span class="p">[</span><span class="nt">EqualityExpression</span><span class="p">[</span><span class="na">@Image</span><span class="err">=</span><span class="s1">'!='</span><span class="p">]</span><span class="o">//</span><span class="nt">NullLiteral</span><span class="w">
</span><span class="ow">and</span><span class="w">
</span><span class="nt">InstanceOfExpression</span><span class="w">
</span><span class="p">[</span><span class="nt">PrimaryExpression</span><span class="p">[</span><span class="nf">count</span><span class="p">(</span><span class="nt">PrimarySuffix</span><span class="p">[</span><span class="na">@ArrayDereference</span><span class="err">=</span><span class="s1">'true'</span><span class="p">])</span><span class="err">=</span><span class="m">0</span><span class="p">]</span><span class="w">
</span><span class="o">//</span><span class="nt">Name</span><span class="p">[</span><span class="ow">not</span><span class="p">(</span><span class="nf">contains</span><span class="p">(</span><span class="na">@Image</span><span class="p">,</span><span class="s1">'.'</span><span class="p">))]</span><span class="err">/</span><span class="na">@Image</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="kn">ancestor::</span><span class="nt">ConditionalAndExpression</span><span class="w">
</span><span class="o">/</span><span class="nt">EqualityExpression</span><span class="o">/</span><span class="nt">PrimaryExpression</span><span class="o">/</span><span class="nt">PrimaryPrefix</span><span class="o">/</span><span class="nt">Name</span><span class="err">/</span><span class="na">@Image</span><span class="p">]</span><span class="w">
</span><span class="ow">and</span><span class="w">
</span><span class="p">(</span><span class="nf">count</span><span class="p">(</span><span class="nt">InstanceOfExpression</span><span class="p">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="m">1</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="nf">count</span><span class="p">(</span><span class="err">*</span><span class="p">))</span><span class="w">
</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">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="n">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="n">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>Fields whose scopes are limited to just single methods do not rely on the containing
object to provide them to other methods. They may be better implemented as local variables
within those methods.</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/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">// no reason to exist at the Foo instance level</span>
<span class="kd">public</span> <span class="kt">void</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="k">return</span> <span class="n">x</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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>ignoredAnnotations</td>
<td>lombok.Setter | lombok.Getter | lombok.Builder | lombok.Data | lombok.RequiredArgsConstructor | lombok.AllArgsConstructor | lombok.Value | lombok.NoArgsConstructor</td>
<td>Fully qualified names of the annotation types that should be ignored by this rule</td>
<td>yes. Delimiter is ‘|’.</td>
</tr>
<tr>
<td>checkInnerClasses</td>
<td>false</td>
<td>Check inner classes</td>
<td>no</td>
</tr>
<tr>
<td>disallowNotAssignment</td>
<td>false</td>
<td>Disallow violations where the first usage is not an assignment</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/SingularField"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>
<h2 id="stdcyclomaticcomplexity">StdCyclomaticComplexity</h2>
<p><span style="border-radius: 0.25em; color: #fff; padding: 0.2em 0.6em 0.3em; display: inline; background-color: #d9534f;">Deprecated</span></p>
<p><strong>Since:</strong> PMD 5.1.2</p>
<p><strong>Priority:</strong> Medium (3)</p>
<p>Complexity directly affects maintenance costs is determined by the number of decision points in a method
plus one for the method entry. The decision points include ‘if’, ‘while’, ‘for’, and ‘case labels’ calls.<br />
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.</p>
<p>This rule is deprecated and will be removed with PMD 7.0.0. The rule is replaced
by the rule <a href="pmd_rules_java_design.html#cyclomaticcomplexity"><code class="highlighter-rouge">CyclomaticComplexity</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/StdCyclomaticComplexityRule.java">net.sourceforge.pmd.lang.java.rule.design.StdCyclomaticComplexityRule</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">// This has a Cyclomatic Complexity = 12</span>
<span class="mi">1</span> <span class="kd">public</span> <span class="kt">void</span> <span class="nf">example</span><span class="o">()</span> <span class="o">{</span>
<span class="mi">2</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="n">c</span> <span class="o">==</span> <span class="n">d</span> <span class="o">&amp;&amp;</span> <span class="n">e</span> <span class="o">==</span> <span class="n">f</span><span class="o">))</span> <span class="o">{</span> <span class="c1">// Only one</span>
<span class="mi">3</span> <span class="k">if</span> <span class="o">(</span><span class="n">a1</span> <span class="o">==</span> <span class="n">b1</span><span class="o">)</span> <span class="o">{</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="mi">4</span> <span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="n">a2</span> <span class="o">==</span> <span class="n">b2</span><span class="o">)</span> <span class="o">{</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="o">}</span>
<span class="mi">5</span> <span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">c</span> <span class="o">==</span> <span class="n">d</span><span class="o">)</span> <span class="o">{</span>
<span class="mi">6</span> <span class="k">while</span> <span class="o">(</span><span class="n">c</span> <span class="o">==</span> <span class="n">d</span><span class="o">)</span> <span class="o">{</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="o">}</span>
<span class="mi">7</span> <span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">e</span> <span class="o">==</span> <span class="n">f</span><span class="o">)</span> <span class="o">{</span>
<span class="mi">8</span> <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">n</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="n">h</span><span class="o">;</span> <span class="n">n</span><span class="o">++)</span> <span class="o">{</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span> <span class="k">else</span><span class="o">{</span>
<span class="k">switch</span> <span class="o">(</span><span class="n">z</span><span class="o">)</span> <span class="o">{</span>
<span class="mi">9</span> <span class="k">case</span> <span class="mi">1</span><span class="o">:</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="k">break</span><span class="o">;</span>
<span class="mi">10</span> <span class="k">case</span> <span class="mi">2</span><span class="o">:</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="k">break</span><span class="o">;</span>
<span class="mi">11</span> <span class="k">case</span> <span class="mi">3</span><span class="o">:</span>
<span class="n">fiddle</span><span class="o">();</span>
<span class="k">break</span><span class="o">;</span>
<span class="mi">12</span> <span class="k">default</span><span class="o">:</span>
<span class="n">fiddle</span><span class="o">();</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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>showMethodsComplexity</td>
<td>true</td>
<td>Add method average violations to the report</td>
<td>no</td>
</tr>
<tr>
<td>showClassesComplexity</td>
<td>true</td>
<td>Add class average violations to the report</td>
<td>no</td>
</tr>
<tr>
<td>reportLevel</td>
<td>10</td>
<td>Cyclomatic Complexity reporting threshold</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/StdCyclomaticComplexity"</span> <span class="nt">/&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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>topscore</td>
<td> </td>
<td>Top score value</td>
<td>no</td>
</tr>
<tr>
<td>minimum</td>
<td> </td>
<td>Minimum reporting threshold</td>
<td>no</td>
</tr>
<tr>
<td>sigma</td>
<td> </td>
<td>Sigma value</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/SwitchDensity"</span> <span class="nt">/&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 Java class:</strong> <a href="https://github.com/pmd/pmd/blob/master/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/TooManyFieldsRule.java">net.sourceforge.pmd.lang.java.rule.design.TooManyFieldsRule</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">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="n">Date</span> <span class="n">birthDate</span><span class="o">;</span>
<span class="n">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>maxfields</td>
<td>15</td>
<td>Max allowable fields</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/TooManyFields"</span> <span class="nt">/&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">ClassOrInterfaceDeclaration</span><span class="o">/</span><span class="nt">ClassOrInterfaceBody</span><span class="w">
</span><span class="p">[</span><span class="w">
</span><span class="nf">count</span><span class="p">(.</span><span class="o">/</span><span class="nt">ClassOrInterfaceBodyDeclaration</span><span class="o">/</span><span class="nt">MethodDeclaration</span><span class="o">/</span><span class="nt">MethodDeclarator</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="nf">starts-with</span><span class="p">(</span><span class="na">@Image</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">@Image</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">@Image</span><span class="p">,</span><span class="s1">'is'</span><span class="p">)</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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>maxmethods</td>
<td>10</td>
<td>The method count reporting threshold</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/TooManyMethods"</span> <span class="nt">/&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="n">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="n">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="n">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>
<th>Multivalued</th>
</tr>
</thead>
<tbody>
<tr>
<td>ignoreAnnotations</td>
<td>false</td>
<td>Ignore annotations</td>
<td>no</td>
</tr>
</tbody>
</table>
<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/UselessOverridingMethod"</span> <span class="nt">/&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="na">@Public</span><span class="p">]</span><span class="o">/</span><span class="nt">MethodDeclarator</span><span class="o">/</span><span class="nt">FormalParameters</span><span class="p">[</span><span class="w">
</span><span class="nf">count</span><span class="p">(</span><span class="nt">FormalParameter</span><span class="o">/</span><span class="nt">Type</span><span class="o">/</span><span class="nt">ReferenceType</span><span class="o">/</span><span class="nt">ClassOrInterfaceType</span><span class="p">[</span><span class="na">@Image</span><span class="w"> </span><span class="err">=</span><span class="w"> </span><span class="s1">'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="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">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="n">String</span> <span class="n">username</span><span class="o">,</span>
<span class="n">String</span> <span class="n">pssd</span><span class="o">,</span>
<span class="n">String</span> <span class="n">databaseName</span><span class="o">,</span>
<span class="n">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>
<hr class="shaded"/>
<footer>
<div class="row">
<div class="col-lg-12 footer">
&copy;2019 PMD Open Source Project. All rights reserved. <br />
Site last generated: Feb 8, 2019 <br />
<p><img src="images/pmd-logo-small.png" alt="Company logo"/></p>
</div>
</div>
</footer>
</div>
<!-- /.row -->
</div>
<!-- /.container -->
</div>
</div>
</body>
</html>
Reference in New Issue View Git Blame Copy Permalink