Checkstyle Parameter Assignments

Standard Checks

The Standard Checkstyle Checks are applicable to general Java coding style and require no external libraries. The standard checks are included in the base distribution.

The site navigation menu lets you browse the individual checks by functionality.

Checkstyle provides many checks that you can apply to your source code. Below is an alphabetical reference, the site navigation menu provides a reference organized by functionality.

AbbreviationAsWordInNameThe Check validate abbreviations(consecutive capital letters) length in identifier name, it also allow in enforce camel case naming.
AbstractClassName Ensures that the names of abstract classes conforming to some regular expression.
AnnotationLocationCheck location of annotation on language elements.
AnnotationOnSameLineThe check does verifying that annotations are located on the same line with their targets.
AnnotationUseStyleThis check controls the style with the usage of annotations.
AnonInnerLengthChecks for long anonymous inner classes.
ArrayTrailingCommaChecks if array initialization contains optional trailing comma.
ArrayTypeStyleChecks the style of array type definitions.
AtclauseOrderChecks the order of at-clauses.
AvoidEscapedUnicodeCharactersRestrict using Unicode escapes.
AvoidInlineConditionalsDetects inline conditionals.
AvoidNestedBlocksFinds nested blocks.
AvoidStarImportCheck that finds import statements that use the * notation.
AvoidStaticImportCheck that finds static imports.
BooleanExpressionComplexity Restricts nested boolean operators (&&, ||, &, | and ^) to a specified depth (default = 3).
CatchParameterNameChecks that catch parameter names conform to a format specified by the format property.
ClassDataAbstractionCouplingThis metric measures the number of instantiations of other classes within the given class.
ClassFanOutComplexityThe number of other classes a given class relies on.
ClassTypeParameterName Checks that class type parameter names conform to a format specified by the format property.
CommentsIndentationControls the indentation between comments and surrounding code.
ConstantNameChecks that constant names conform to a format specified by the format property.
CovariantEquals Checks that if a class defines a covariant method equals, then it defines method equals(java.lang.Object).
CustomImportOrder Checks that the groups of import declarations appear in the order specified by the user.
CyclomaticComplexityChecks cyclomatic complexity against a specified limit.
DeclarationOrder Checks that the parts of a class or interface declaration appear in the order suggested by the Code Conventions for the Java Programming Language.
DefaultComesLast Check that the is after all the s in a statement.
DescendantTokenChecks for restricted tokens beneath other tokens.
DesignForExtensionChecks that classes are designed for inheritance.
EmptyBlockChecks for empty blocks but does not validate sequential blocks.
EmptyCatchBlockChecks for empty catch blocks with few options to skip violation.
EmptyForInitializerPadChecks the padding of an empty for initializer; that is whether a space is required at an empty for initializer, or such spaces are forbidden.
EmptyForIteratorPadChecks the padding of an empty for iterator; that is whether a space is required at an empty for iterator, or such spaces are forbidden.
EmptyLineSeparatorChecks for blank line separators.
EmptyStatement Detects empty statements (standalone ';').
EqualsAvoidNull Checks that any combination of String literals is on the left side of an equals() comparison.
EqualsHashCode Checks that classes that override equals() also override hashCode().
ExecutableStatementCount Restricts the number of executable statements to a specified limit (default = 30).
ExplicitInitialization Checks if any class or object member explicitly initialized to default for its type value ( for object references, zero for numeric types and and for .
FallThroughChecks for fall through in switch statements Finds locations where a case contains Java code - but lacks a break, return, throw or continue statement.
FileLength Checks for long source files.
FileTabCharacterChecks to see if a file contains a tab character.
FinalClass Checks that class which has only private constructors is declared as final.
FinalLocalVariable Ensures that local variables that never get their values changed, must be declared final.
FinalParametersCheck that method/constructor/catch/foreach parameters are final.
GenericWhitespaceChecks that the whitespace around the Generic tokens < and > are correct to the typical convention.
HeaderChecks the header of the source against a fixed header file.
HiddenFieldChecks that a local variable or a parameter does not shadow a field that is defined in the same class.
HideUtilityClassConstructorMake sure that utility classes (classes that contain only static methods) do not have a public constructor.
IllegalCatchCatching java.lang.Exception, java.lang.Error or java.lang.RuntimeException is almost never acceptable.
IllegalImport Checks for imports from a set of illegal packages.
IllegalInstantiation Checks for illegal instantiations where a factory method is preferred.
IllegalThrowsThrowing java.lang.Error or java.lang.RuntimeException is almost never acceptable.
IllegalToken Checks for illegal tokens.
IllegalTokenText Checks for illegal token text.
IllegalType Checks that particular class are never used as types in variable declarations, return values or parameters.
ImportControlCheck that controls what packages can be imported in each package.
ImportOrderEnsures that groups of imports come in a specific order.
IndentationChecks correct indentation of Java Code.
InnerAssignment Checks for assignments in subexpressions, such as in .
InnerTypeLast Check nested (internal) classes/interfaces are declared at the bottom of the class after all method and field declarations.
InterfaceIsTypeImplements Bloch, Effective Java, Item 17 - Use Interfaces only to define types.
InterfaceTypeParameterName Checks that interface type parameter names conform to a format specified by the format property.
JavadocMethodChecks the Javadoc of a method or constructor.
JavadocPackageChecks that all packages have a package documentation.
JavadocParagraphChecks Javadoc paragraphs.
JavadocStyleCustom Checkstyle Check to validate Javadoc.
JavadocTagContinuationIndentationChecks the indentation of the continuation lines in at-clauses.
JavadocTypeChecks the Javadoc of a type.
JavadocVariableChecks that a variable has Javadoc comment.
JavaNCSSThis check calculates the Non Commenting Source Statements (NCSS) metric for Java source files and methods.
LeftCurly Checks the placement of left curly braces on types, methods and other blocks:
LineLengthChecks for long lines.
LocalFinalVariableName Checks that local final variable names conform to a format specified by the format property.
LocalVariableName Checks that local, non-final variable names conform to a format specified by the format property.
MagicNumber Checks for magic numbers.
MemberName Checks that instance variable names conform to a format specified by the format property.
MethodCountChecks the number of methods declared in each type declaration by access modifier or total count.
MethodLength Checks for long methods.
MethodName Checks that method names conform to a format specified by the format property.
MethodParamPad Checks the padding between the identifier of a method definition, constructor definition, method call, or constructor invocation; and the left parenthesis of the parameter list.
MethodTypeParameterName Checks that class type parameter names conform to a format specified by the format property.
MissingCtor Checks that classes (except abstract one) define a ctor and don't rely on the default one.
MissingDeprecated This class is used to verify that both the java.lang.Deprecated annotation is present and the @deprecated Javadoc tag is present when either is present.
MissingOverride This class is used to verify that the java.lang.Override annotation is present when the {@inheritDoc} javadoc tag is present.
MissingSwitchDefault Checks that switch statement has "default" clause.
ModifiedControlVariableCheck for ensuring that for loop control variables are not modified inside the for block.
ModifierOrder Checks that the order of modifiers conforms to the suggestions in the Java Language specification, sections 8.1.1, 8.3.1 and 8.4.3.
MultipleStringLiteralsChecks for multiple occurrences of the same string literal within a single file.
MultipleVariableDeclarations Checks that each variable declaration is in its own statement and on its own line.
MutableException Ensures that exceptions (defined as any class name conforming to some regular expression) are immutable.
NeedBraces Checks for braces around code blocks.
NestedForDepthRestricts nested blocks to a specified depth (default = 1).
NestedIfDepthRestricts nested if-else blocks to a specified depth (default = 1).
NestedTryDepthRestricts nested try-catch-finally blocks to a specified depth (default = 1).
NewlineAtEndOfFile Checks that there is a newline at the end of each file.
NoClone Checks that the clone method is not overridden from the Object class.
NoFinalizerChecks that no method having zero parameters is defined using the name finalize.
NoLineWrap Checks that chosen statements are not line-wrapped.
NonEmptyAtclauseDescription Checks that the at-clause tag is followed by description .
NoWhitespaceAfter Checks that there is no whitespace after a token.
NoWhitespaceBefore Checks that there is no whitespace before a token.
NPathComplexityChecks the npath complexity against a specified limit (default = 200).
OneStatementPerLineChecks that there is only one statement per line.
OneTopLevelClassChecks that each top-level class, interfaces or enum resides in a source file of its own.
OperatorWrap Checks line wrapping for operators.
OuterTypeFilenameChecks that the outer type name and the file name match.
OuterTypeNumberChecks for the number of defined types at the "outer" level.
OverloadMethodsDeclarationOrderChecks that overload methods are grouped together.
PackageAnnotationThis check makes sure that all package annotations are in the package-info.java file.
PackageDeclarationEnsures there is a package declaration and (optionally) in the correct directory.
PackageName Checks that package names conform to a format specified by the format property.
ParameterAssignment Disallow assignment of parameters.
ParameterName Checks that parameter names conform to a format specified by the format property.
ParameterNumber Checks the number of parameters that a method or constructor has.
ParenPadChecks the padding of parentheses; that is whether a space is required after a left parenthesis and before a right parenthesis, or such spaces are forbidden, with the exception that it does not check for padding of the right parenthesis at an empty for iterator.
RedundantImport Checks for imports that are redundant.
RedundantModifierChecks for redundant modifiers in interface and annotation definitions, final modifier on methods of final classes, inner declarations that are declared as , non public class constructors and enum constructors, nested enum definitions that are declared as .
Regexp A check that makes sure that a specified pattern exists (or not) in the file.
RegexpHeaderChecks the header of the source against a header file that contains a
RegexpMultilineImplementation of a check that looks that matches across multiple lines in any file type.
RegexpOnFilenameImplementation of a check that matches based on file and/or folder path.
RegexpSinglelineImplementation of a check that looks for a single line in any file type.
RegexpSinglelineJavaImplementation of a check that looks for a single line in Java files.
RequireThisChecks that code doesn't rely on the "this" default.
ReturnCount Restricts return statements to a specified count (default = 2).
RightCurly Checks the placement of right curly braces.
SeparatorWrap Checks line wrapping with separators.
SimplifyBooleanExpression Checks for overly complicated boolean expressions.
SimplifyBooleanReturn Checks for overly complicated boolean return statements.
SingleLineJavadoc Checks that a JavaDoc block which can fit on a single line and doesn't contain at-clauses
SingleSpaceSeparator Checks that non-whitespace characters are separated by no more than one whitespace.
StaticVariableName Checks that static, non-final variable names conform to a format specified by the format property.
StringLiteralEqualityChecks that string literals are not used with or .
SummaryJavadoc Checks that Javadoc summary sentence does not contain phrases that are not recommended to use.
SuperClone Checks that an overriding clone() method invokes super.clone().
SuperFinalize Checks that an overriding finalize() method invokes super.finalize().
SuppressWarnings This check allows you to specify what warnings that
ThrowsCount Restricts throws statements to a specified count (default = 4).
TodoComment A check for TODO comments.
TrailingComment The check to ensure that requires that comments be the only thing on a line.
Translation The TranslationCheck class helps to ensure the correct translation of code by checking property files for consistency regarding their keys.
TypecastParenPadChecks the padding of parentheses for typecasts.
TypeName Checks that type names conform to a format specified by the format property.
UncommentedMainDetects uncommented main methods.
UniquePropertiesDetects duplicated keys in properties files.
UnnecessaryParentheses Checks if unnecessary parentheses are used in a statement or expression.
UnusedImports Checks for unused import statements.
UpperEllChecks that long constants are defined with an upper ell.
VariableDeclarationUsageDistanceChecks the distance between declaration of variable and its first usage.
VisibilityModifierChecks visibility of class members.
WhitespaceAfter Checks that a token is followed by whitespace, with the exception that it does not check for whitespace after the semicolon of an empty for iterator.
WhitespaceAround Checks that a token is surrounded by whitespace.
WriteTag Outputs a JavaDoc tag as information.

Holder Checks

These checks aren't normal checks and are usually associated with a specialized filter to gather information the filter can't get on it's own.

SuppressWarningsHolder Maintains a set of check suppressions from annotations.

I consider in method parameters and local variables to be code noise. Java method declarations can be quite long (especially with generics) - there's no need to make them any longer.

If unit tests are written properly, assigning to parameters that is "harmful" will be picked up, so it should never actually be a problem. Visual clarity is more important than avoiding a possible bug that isn't picked up because your unit tests have insufficient coverage.

Tools like FindBugs and CheckStyle that can be configured to break the build if assignment is made to parameters or local variables, if you deeply care about such things.

Of course, if you need to make them final, for example because you're using the value in an anonymous class, then no problem - that's the simplest cleanest solution.

Apart from the obvious effect of adding extra keywords to your parameters, and thereby IMHO camouflaging them, adding final to method parameters can often make the code in the method body become less readable, which makes the code worse - to be "good", code must be as readable and as simple as possible. For a contrived example, say I have a method that needs to work case insensitively.

Without :

Simple. Clean. Everybody knows what's going on.

Now with 'final', option 1:

While making the parameters stops the coder adding code further down from thinking he's working with the original value, there's an equal risk that code further down may use instead of , which it shouldn't and which can't protected against, because you can't take it out of scope (or even assign to if that would even help anyway).

With 'final', option 2:

Now we're just created even more code noise and introduced a performance hit of having to invoke n times.

With 'final', option 3:

Talk about code noise. This is a train wreck. We've got a new method, a required exception block, because other code may invoke it incorrectly. More unit tests to cover the exception. All to avoid one simple, and IMHO preferable and harmless, line.

There's also the issue that methods should not be so long that you can't easily visually take it in and know at a glance that an assignment to parameter has taken place.

I do think it is good practice/style that if you assign to a parameter you do it every early in the method, preferably first line or straight after basic input checking, effectively replacing it for the entire method, which has a consistent effect within the method. Readers know to expect any assignment to be obvious (near the signature declaration) and in a consistent place, which greatly mitigates the problem that adding final is trying to avoid. Actually I rarely assign to parameters, but if I do I always do it at the top of a method.


Note also that doesn't actually protect you like it may at first seem:

doesn't completely protect you unless the parameter type is primitive or immutable.

One thought on “Checkstyle Parameter Assignments

Leave a Reply

Your email address will not be published. Required fields are marked *