Quality profiles / java / Sun checks

Checks the style of array type definitions. Some like Java-style: public static void main(String[] args) and some like C-style: public static void main(String args[])

Detects inline conditionals.

Finds nested blocks.

Check that finds import statements that use the * notation.

Checks that class parameter names conform to the specified format

The following code snippet illustrates this rule for format "^[A-Z]$":

class Something<type> { // Non-compliant
}

class Something<T> { // Compliant
}

This rule allows to find any kind of pattern inside comments like TODO, NOPMD, ..., except NOSONAR

Checks that constant names conform to the specified format

Detect the double-checked locking idiom, a technique that tries to avoid synchronization overhead but is incorrect because of subtle artifacts of the java memory model.

Checks for empty blocks.

Checks the padding of an empty for iterator; that is whether a space is required at an empty for iterator, or such spaces are forbidden. Example : for (Iterator foo = very.long.line.iterator(); foo.hasNext(); )

Detects empty statements (standalone ';').

Checks that classes that override equals() also override hashCode().

Checks for long source files.

Rationale: If a source file becomes very long it is hard to understand. Therefore long classes should usually be refactored into several individual classes that focus on a specific task.

Checks that there are no tab characters ('\t') in the source code. Rationale:

• Developers should not need to configure the tab width of their text editors in order to be able to read source code.
• From the Apache jakarta coding standards: In a distributed development environment, when the commit messages get sent to a mailing list, they are almost impossible to read if you use tabs.

Checks that class which has only private constructors is declared as final.

Check that method/constructor/catch/foreach parameters are final.

Checks that a local variable or a parameter does not shadow a field that is defined in the same class.

Make sure that utility classes (classes that contain only static methods) do not have a public constructor.

Checks for imports from a set of illegal packages, like sun.*

Checks for assignments in subexpressions, such as in String s = Integer.toString(i = 2);.

Implements Bloch, Effective Java, Item 17 - Use Interfaces only to define types. According to Bloch, an interface should describe a type. It is therefore inappropriate to define an interface that does not contain any methods but only constants. The Standard class javax.swing.SwingConstants is an example of a class that would be flagged by this check. The check can be configured to also disallow marker interfaces like java.io.Serializable, that do not contain methods or constants at all.

Checks the Javadoc of a method or constructor. By default, does not check for unused throws. To allow documented java.lang.RuntimeExceptions that are not declared, set property allowUndeclaredRTE to true. The scope to verify is specified using the Scope class and defaults to Scope.PRIVATE. To verify another scope, set property scope to a different scope.

Error messages about parameters and type parameters for which no param tags are present can be suppressed by defining property allowMissingParamTags. Error messages about exceptions which are declared to be thrown, but for which no throws tag is present can be suppressed by defining property allowMissingThrowsTags. Error messages about methods which return non-void but for which no return tag is present can be suppressed by defining property allowMissingReturnTag.

Javadoc is not required on a method that is tagged with the @Override annotation. However under Java 5 it is not possible to mark a method required for an interface (this was corrected under Java 6). Hence Checkstyle supports using the convention of using a single {@inheritDoc} tag instead of all the other tags.

Note that only inheritable items will allow the {@inheritDoc} tag to be used in place of comments. Static methods at all visibilities, private non-static methods and constructors are not inheritable.

Validates Javadoc comments to help ensure they are well formed. The following checks are performed:

• Ensures the first sentence ends with proper punctuation (That is a period, question mark, or exclamation mark, by default). Javadoc automatically places the first sentence in the method summary table and index. With out proper punctuation the Javadoc may be malformed. All items eligible for the {@inheritDoc} tag are exempt from this requirement.
• Check text for Javadoc statements that do not have any description. This includes both completely empty Javadoc, and Javadoc with only tags such as @param and @return.
• Check text for incomplete HTML tags. Verifies that HTML tags have corresponding end tags and issues an "Unclosed HTML tag found:" error if not. An "Extra HTML tag found:" error is issued if an end tag is found without a previous open tag.
• Check that a package Javadoc comment is well-formed (as described above) and NOT missing from any package-info.java files.
• Check for allowed HTML tags. The list of allowed HTML tags is "a", "abbr", "acronym", "address", "area", "b", "bdo", "big", "blockquote", "br", "caption", "cite", "code", "colgroup", "del", "div", "dfn", "dl", "em", "fieldset", "h1" to "h6", "hr", "i", "img", "ins", "kbd", "li", "ol", "p", "pre", "q", "samp", "small", "span", "strong", "sub", "sup", "table", "tbody", "td", "tfoot", "th", "thread", "tr", "tt", "ul"

Checks Javadoc comments for class and interface definitions. By default, does not check for author or version tags. The scope to verify is specified using the Scope class and defaults to Scope.PRIVATE. To verify another scope, set property scope to one of the Scope constants. To define the format for an author tag or a version tag, set property authorFormat or versionFormat respectively to a regular expression.

Error messages about type parameters for which no param tags are present can be suppressed by defining property allowMissingParamTags.

Checks that a variable has Javadoc comment.

Checks for the placement of left curly braces for code blocks. The policy to verify is specified using property option. Policies eol and nlow take into account property maxLineLength.

Checks for long lines.

Checks that local final variable names, including catch parameters, conform to the specified format

Checks that local, non-final variable names conform to the specified format

Checks for magic numbers.

Checks that name of non-static fields conform to the specified format

Checks for long methods.

Checks that method names conform to the specified format

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.

Checks that method type parameter names conform to the specified format

The following code snippet illustrates this rule for format "^[A-Z]$":

public <type> boolean containsAll(Collection<type> c) { // Non-compliant
  return null;
}

public <T> boolean containsAll(Collection<T> c) { // Compliant
}

Checks that switch statement has default clause.

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. The correct order is : public, protected, private, abstract, static, final, transient, volatile, synchronized, native, strictfp.

Checks for braces around code blocks.

Checks that there is a newline at the end of each file. Any source files and text files in general should end with a newline character, especially when using SCM systems such as CVS. CVS will even print a warning when it encounters a file that doesn't end with a newline.

Checks that there is no whitespace after a token.

Checks that there is no whitespace before a token.

Checks the policy on how to wrap lines on operators.

Checks that package names conform to the specified format. The default value of format has been chosen to match the requirements in the Java Language specification and the Sun coding conventions. However both underscores and uppercase letters are rather uncommon, so most configurations should probably assign value ^[a-z]+(\.[a-z][a-z0-9]*)*$ to format

Checks that parameter names conform to the specified format

Checks the number of parameters that a method or constructor has.

Checks 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.

Checks for redundant modifiers in interface and annotation definitions.

Checks for redundant exceptions declared in throws clause such as duplicates, unchecked exceptions or subclasses of another declared exception.

Checks the placement of right curly braces.

Constructors and methods receiving arrays should clone objects and store the copy. This prevents that future changes from the user affect the internal functionality.

Exposing internal arrays directly allows the user to modify some code that could be critical. It is safer to return a copy of the array.

Checks for overly complicated boolean expressions.

Checks for overly complicated boolean return statements.

Checks that static, non-final fields conform to the specified format

Checks that type names conform to the specified format

Checks the padding of parentheses for typecasts.

Checks for unused import statements.

Checks that long constants are defined with an upper ell. That is ' L' and not 'l'. This is in accordance to the Java Language Specification, Section 3.10.1.

Checks visibility of class members. Only static final members may be public; other class members must be private unless property protectedAllowed or packageAllowed is set.

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.

Checks that a token is surrounded by whitespace.