com.puppycrawl.tools.checkstyle.checks.coding

Contains the Coding checks that are bundled with the main distribution.

Abstract class for checking that an overriding method with no parameters invokes the super method.

Checks if array initialization contains optional trailing comma.

Checks that if a class defines a covariant method equals, then it defines method equals(java.lang.Object).

Checks that the parts of a class or interface declaration appear in the order suggested by the Code Conventions for the Java Programming Language.

1. Class (static) variables.

Check that the default is after all the cases in a switch statement.

Rationale: Java allows default anywhere within the switch statement.

Detects empty statements (standalone ';').

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

Rationale: The contract of equals() and hashCode() requires that equal objects have the same hashCode.

Checks if any class or object member explicitly initialized to default for its type value (null for object references, zero for numeric types and char and false for boolean.

Rationale: each instance variable gets initialized twice, to the same value.

The check honors special comments to suppress warnings about the fall through.

Ensures that local variables that never get their values changed, must be declared final.

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

Checks for illegal instantiations where a factory method is preferred.

Checks for illegal tokens.

Rational: Certain language features are often lead to hard to maintain code or are non-obvious to novice developers.

Checks for illegal token text.

Checks that particular class are never used as types in variable declarations, return values or parameters.

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

Checks for magic numbers.

Checks that classes (except abstract one) define a ctor and don't rely on the default one.

Checks that switch statement has "default" clause.

Rationale: It's usually a good idea to introduce a default case in every switch statement.

Checks that each variable declaration is in its own statement and on its own line.

Disallow assignment of parameters.

Rationale: Parameter assignment is often considered poor programming practice.

Checks that code doesn't rely on the "this" default. That is references to instance variables and methods of the present object are explicitly of the form "this.varName" or "this.methodName(args)".

Examples of use:

 <module name="RequireThis"/>
 

 <module name="RequireThis">
 <property name="checkFields" value="false"/>
 <property name="checkMethods" value="true"/>
 </module>
 

Limitations: I'm not currently doing anything about static variables or catch-blocks.

Restricts return statements to a specified count (default = 2).

Checks for overly complicated boolean expressions.

Checks for overly complicated boolean return statements.

Checks that string literals are not used with == or !=.

Checks that an overriding clone() method invokes super.clone().

Checks that an overriding finalize() method invokes super.finalize().

Checks if unnecessary parentheses are used in a statement or expression. The check will flag the following with warnings:

 return (x);          // parens around identifier
 return (x + 1);      // parens around return value
 int x = (y / 2 + 1); // parens around assignment rhs
 for (int i = (0); i < 10; i++) {  // parens around literal
 t -= (z + 1);        // parens around assignment rhs

The check is not "type aware", that is to say, it can't tell if parentheses are unnecessary based on the types in an expression.