src/main/resources/net/kemitix | ||
.gitignore | ||
CHANGELOG | ||
LICENSE.md | ||
pom.xml | ||
README.md |
kemitix-checkstyle-ruleset
Provides an extensive Checkstyle ruleset for use with Apache's maven-checkstyle-plugin
.
The ruleset includes checks from both the core Checkstyle library and from the Sevntu-Checkstyle library.
Requirements
- maven-checkstyle-plugin 2.17+
- Checkstyle 7.0+
- Sevntu-checkstyle 1.21.0+
Usage
To use this ruleset in your maven-checkstyle-plugin
configuration add checkstyle
, sevntu-checkstyle-maven-plugin
and kemitix-checktyle-ruleset
as dependencies of the maven-checkstyle-plugin
.
You need to include checkstyle
as the version bundled with the maven-checkstyle-plugin
is not up-to-date enough.
<properties>
<checkstyle.version>7.0</checkstyle.version>
<sevntu-checkstyle-maven-plugin.version>1.21.0</sevntu-checkstyle-maven-plugin.version>
<kemitix-checkstyle-ruleset.version>0.1.1</kemitix-checkstyle-ruleset.version>
</properties>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
<dependencies>
<dependency>
<groupId>com.puppycrawl.tools</groupId>
<artifactId>checkstyle</artifactId>
<version>${checkstyle.version}</version>
</dependency>
<dependency>
<groupId>com.github.sevntu.checkstyle</groupId>
<artifactId>sevntu-checkstyle-maven-plugin</artifactId>
<version>${sevntu-checkstyle-maven-plugin.version}</version>
</dependency>
<dependency>
<groupId>net.kemitix</groupId>
<artifactId>kemitix-checkstyle-ruleset</artifactId>
<version>${kemitix-checkstyle-ruleset.version}</version>
</dependency>
<configuration>
<configLocation>net/kemitix/checkstyle.xml</configLocation>
</configuration>
</dependencies>
</plugin><!-- maven-checkstyle-plugin -->
</plugins>
</pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
<executions>
<execution>
<id>validate</id>
<phase>validate</phase>
<goals>
<goal>check</goal>
<goal>checkstyle</goal>
</goals>
</execution>
</executions>
</plugin><!-- maven-checkstyle-plugin -->
</plugins>
All Checks
- AbbreviationAsWordInName - checkstyle - enabled
- AbstractClassName - checkstyle - enabled
- AnnotationLocation - checkstyle - enabled
- AnnotationUseStyle - checkstyle - enabled
- AnonInnerLength - checkstyle - enabled
- ArrayTrailingComma - checkstyle - disabled
- ArrayTypeStyle - checkstyle - enabled
- AtclauseOrder - checkstyle - enabled
- AvoidConditionInversion - sevntu - disabled
- AvoidConstantAsFirstOperandInCondition - sevntu - enabled
- AvoidDefaultSerializableInInnerClasses - sevntu - disabled
- AvoidEscapedUnicodeCharacters - checkstyle - enabled
- AvoidHidingCauseException - sevntu - enabled
- AvoidInlineConditionals - checkstyle - enabled
- AvoidModifiersForTypes - sevntu - disabled
- AvoidNestedBlocks - checkstyle - enabled
- AvoidNotShortCircuitOperatorsForBoolean - sevntu - enabled
- AvoidStarImport - checkstyle - enabled
- AvoidStaticImport - checkstyle - enabled
- BooleanExpressionComplexity - checkstyle - enabled
- CatchParameterName - checkstyle - enabled
- CauseParameterInException - sevntu - disabled
- ChildBlockLength - sevntu - disabled
- ClassDataAbstractionCoupling - checkstyle - enabled
- ClassFanOutComplexity - checkstyle - enabled
- ClassTypeParameterName - checkstyle - enabled
- CommentsIndentation - checkstyle - enabled
- ConfusingCondition - sevntu - enabled
- ConstantName - checkstyle - enabled - insuppressible
- ConstructorWithoutParams - sevntu - enabled
- CovariantEquals - checkstyle - enabled - insuppressible
- CustomDeclarationOrder - sevntu - disabled
- CyclomaticComplexity - checkstyle - enabled
- DeclarationOrder - checkstyle - enabled
- DefaultComesLast - checkstyle - enabled
- DesignForExtension - checkstyle - enabled
- DiamondOperatorForVariableDefinition - sevntu - enabled
- EitherLogOrThrow - sevntu - enabled
- EmptyBlock - checkstyle - enabled
- EmptyCatchBlock - checkstyle - enabled
- EmptyForInitializerPad - checkstyle - enabled
- EmptyForIteratorPad - checkstyle - enabled
- EmptyLineSeparator - checkstyle - enabled
- EmptyPublicCtorInClass - sevntu - disabled
- EmptyStatement - checkstyle - enabled
- EnumValueName - sevntu - enabled
- EqualsAvoidNull - checkstyle - enabled
- EqualsHashCode - checkstyle - enabled - insuppressible
- ExecutableStatementCount - checkstyle - enabled
- ExplicitInitialization - checkstyle - enabled
- FallThrough - checkstyle - enabled
- FileLength - checkstyle - enabled
- FileTabCharacter - checkstyle - enabled
- FinalClass - checkstyle - enabled
- FinalizeImplementation - sevntu - disabled
- FinalLocalVariable - checkstyle - enabled
- FinalParameters - checkstyle - enabled
- ForbidAnnotation - sevntu - disabled
- ForbidCCommentsInMethods - sevntu - enabled
- ForbidCertainImports - sevntu - disabled
- ForbidInstantiation - sevntu - disabled
- ForbidReturnInFinallyBlock - sevntu - enabled
- ForbidThrowAnonymousExceptions - sevntu - disabled
- ForbidWildcardAsReturnType - sevntu - enabled
- GenericWhitespace - checkstyle - enabled
- Header - checkstyle - disabled
- HiddenField - checkstyle - enabled
- HideUtilityClassConstructor - checkstyle - enabled
- HideUtilityClassConstructor - sevntu - disabled
- IllegalCatchExtended - sevntu - disabled
- IllegalCatch - checkstyle - enabled
- IllegalImport - checkstyle - enabled
- IllegalInstantiation - checkstyle - disabled
- IllegalThrows - checkstyle - enabled
- IllegalToken - checkstyle - enabled
- IllegalTokenText - checkstyle - disabled
- IllegalType - checkstyle - enabled
- ImportControl - checkstyle - disabled
- ImportOrder - checkstyle - disabled
- Indentation - checkstyle - disabled
- InnerAssignment - checkstyle - enabled
- InnerClass - sevntu - disabled
- InnerTypeLast - checkstyle - enabled
- InterfaceIsType - checkstyle - enabled
- InterfaceTypeParameterName - checkstyle - enabled
- InterfaceTypeParameterName - sevntu - disabled
- JavadocMethod - checkstyle - enabled
- JavadocPackage - checkstyle - enabled
- JavadocParagraph - checkstyle - enabled
- JavadocStyle - checkstyle - enabled
- JavadocTagContinuationIndentation - checkstyle - disabled
- JavadocType - checkstyle - enabled
- JavadocVariable - checkstyle - disabled
- JavaNCSS - checkstyle - enabled
- LeftCurly - checkstyle - enabled
- LineLengthExtended - sevntu - disabled
- LineLength - checkstyle - enabled
- LocalFinalVariableName - checkstyle - enabled
- LocalVariableName - checkstyle - enabled
- LogicConditionNeedOptimization - sevntu - enabled
- MagicNumber - checkstyle - enabled
- MapIterationInForEachLoop - sevntu - enabled
- MemberName - checkstyle - enabled
- MethodCount - checkstyle - enabled
- MethodLength - checkstyle - enabled
- MethodName - checkstyle - enabled
- MethodParamPad - checkstyle - enabled
- MethodTypeParameterName - checkstyle - enabled
- MissingCtor - checkstyle - disabled
- MissingDeprecated - checkstyle - enabled
- MissingOverride - checkstyle - disabled
- MissingSwitchDefault - checkstyle - enabled
- ModifiedControlVariable - checkstyle - enabled
- ModifierOrder - checkstyle - enabled
- MultipleStringLiterals - checkstyle - enabled
- MultipleStringLiteralsExtended - sevntu - disabled
- MultipleVariableDeclarations - checkstyle - enabled
- MultipleVariableDeclarationsExtended - sevntu - disabled
- MutableException - checkstyle - enabled
- NameConventionForJunit4TestClasses - sevntu - enabled
- NeedBraces - checkstyle - enabled
- NestedForDepth - checkstyle - enabled
- NestedIfDepth - checkstyle - enabled
- NestedSwitch - sevntu - enabled
- NestedTryDepth - checkstyle - enabled
- NewlineAtEndOfFile - checkstyle - enabled
- NoClone - checkstyle - enabled - insuppressible
- NoFinalizer - checkstyle - enabled
- NoLineWrap - checkstyle - enabled
- NoMainMethodInAbstractClass - sevntu - enabled
- NonEmptyAtclauseDescription - checkstyle - enabled
- NoWhitespaceAfter - checkstyle - enabled
- NoWhitespaceBefore - checkstyle - enabled
- NPathComplexity - checkstyle - enabled
- NumericLiteralNeedsUnderscore - sevntu - enabled
- OneStatementPerLine - checkstyle - enabled
- OneTopLevelClass - checkstyle - enabled - insuppressible
- OperatorWrap - checkstyle - enabled
- OuterTypeFilename - checkstyle - enabled - insuppressible
- OuterTypeNumber - checkstyle - disabled
- OverloadMethodsDeclarationOrder - checkstyle - enabled
- OverridableMethodInConstructor - sevntu - enabled
- PackageAnnotation - checkstyle - enabled
- PackageDeclaration - checkstyle - enabled - insuppressible
- PackageName - checkstyle - enabled
- ParameterAssignment - checkstyle - disabled
- ParameterName - checkstyle - enabled
- ParameterNumber - checkstyle - enabled
- ParenPad - checkstyle - enabled
- PublicReferenceToPrivateType - sevntu - enabled
- RedundantImport - checkstyle - disabled
- RedundantModifier - checkstyle - enabled
- RedundantReturn - sevntu - enabled
- Regexp - checkstyle - disabled
- RegexpHeader - checkstyle - disabled
- RegexpMultiline - checkstyle - disabled
- RegexpOnFilename - checkstyle - disabled
- RegexpSingleline - checkstyle - disabled
- RegexpSinglelineJava - checkstyle - disabled
- RequiredParameterForAnnotation - sevntu - disabled
- RequireThis - checkstyle - enabled
- ReturnBooleanFromTernary - sevntu - enabled
- ReturnCount - checkstyle - enabled
- ReturnCountExtended - sevntu - disabled
- ReturnNullInsteadOfBoolean - sevntu - enabled
- RightCurly - checkstyle - enabled
- SeparatorWrap - checkstyle - enabled
- SimpleAccessorNameNotation - sevntu - enabled
- SimplifyBooleanExpression - checkstyle - enabled
- SimplifyBooleanReturn - checkstyle - enabled
- SingleBreakOrContinue - sevntu - enabled
- SingleLineJavadoc - checkstyle - disabled
- SingleSpaceSeparator - checkstyle - enabled
- StaticMethodCandidate - sevntu - disabled
- StaticVariableName - checkstyle - enabled
- StringLiteralEquality - checkstyle - enabled
- SummaryJavadoc - checkstyle - disabled
- SuperClone - checkstyle - disabled
- SuperFinalize - checkstyle - disabled
- SuppressWarnings - checkstyle - enabled
- SuppressWarningsHolder - checkstyle - enabled
- TernaryPerExpressionCount - sevntu - enabled
- ThrowsCount - checkstyle - enabled
- TodoComment - checkstyle - enabled
- TrailingComment - checkstyle - enabled
- Translation - checkstyle - enabled
- TypecastParenPad - checkstyle - enabled
- TypeName - checkstyle - enabled - insuppressible
- UncommentedMain - checkstyle - enabled
- UniformEnumConstantName - sevntu - enabled
- UniqueProperties - checkstyle - enabled
- UnnecessaryParentheses - checkstyle - enabled
- UnnecessaryParenthesesExtended - sevntu - disabled
- UnusedImports - checkstyle - enabled
- UpperEll - checkstyle - enabled
- UselessSingleCatch - sevntu - enabled
- UselessSuperCtorCall - sevntu - enabled
- VariableDeclarationUsageDistance - checkstyle - enabled
- VisibilityModifier - checkstyle - enabled - insuppressible
- WhitespaceAfter - checkstyle - enabled
- WhitespaceAround - checkstyle - enabled
- WhitespaceBeforeArrayInitializer - sevntu - disabled
- WriteTag - checkstyle - disabled
Enabled Checks
The following is a list of each of the checks and the expectations each has on your code.
Checkstyle
Rules are listed in alphabetical order.
AbbreviationAsWordInName
Enforces proper CamelCase
and avoids sequences of consecutive uppercase characters in identifiers. Does not apply to @Overridden methods.
Valid:
class DaoManager {}
Invalid:
class DAOManager {}
AbstractClassName
The name of an abstract
class must start with Abstract
. Classes that start with Abstract
must be abstract
.
Valid:
abstract class AbstractCardHand implements CardHand {}
Invalid:
abstract class BaseCardHand implements CardHand {}
AnnotationLocation
Annotations must be on a line by themselves unless annotating a method parameter or among class modifiers.
Valid:
@Component
@Qualifier("Red")
class RedStick implements Stick {
public @NonNull String getLabel(@Value("${stick.length}") final int length) {
// ...
}
}
Invalid:
@Component @Qualifier("Red")
class RedStick implements Stick {}
AnnotationUseStyle
Annotations should only use brackets and named attributes when they are needed. If only the default parameter is specified, then only the attribute value should be given. If there are no parameters, then no brackets should be given.
Valid:
@Entity
@Table("names")
@MyAnnotation(realm = "external")
Invalid:
@Entity()
@Table(value = "names")
AnonInnerLength
Anonymous inner classes should be no more than 20 lines.
ArrayTypeStyle
Enforces Java style arrays.
Valid:
public static void main(String[] args) {}
Invalid:
public static void main(String args[]) {}
AtclauseOrder
Javadoc @
clauses must be in the order:
/**
*
* @param ...
* @author ...
* @version ...
* @serial ...
* @return ...
* @throws ...
* @exception ...
* @serialData ...
* @serialField ...
* @see ...
* @since ...
* @deprecated ...
*/
AvoidEscapedUnicodeCharacters
Prevents use of obscure escape codes (e.g. \u221e
). However, non-printable/control characters are still permitted.
Valid:
String unitAbbrev = "??s";
String byteOrdered = '\ufeff' = content;
Invalid:
String unitAbbrev = "\u03bcs";
AvoidInlineConditionals
Prevents use of the ?:
operators.
AvoidNestedBlocks
Avoid unnecessary blocks.
Valid:
if (isDebug()) {
// ...
}
Invalid:
// if (isDebug())
{
// ...
}
AvoidStarImport
Prevents the use of the star import.
Invalid:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
AvoidStaticImport
Prevents importing static members, unless they are one of the following:
org.assertj.core.api.Assertions.assertThat
org.mockito.BDDMockito.given
org.mockito.Mockito.*
org.mockito.Matchers.*
org.mockito.Mockito.*
Valid:
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
Invalid:
import static java.nio.charset.StandardCharsets.UTF_8;
BooleanExpressionComplexity
Restrict the number of number of &&, ||, &, | and ^ in an expression to 2.
Valid:
if (a || (b && c)) {}
Invalid:
if (a > b || b > c || c == a || d > a) {}
CatchParameterName
Checks that catch parameter names conform to the following characteristic:
- allows names beginning with two lowercase letters followed by at least one uppercase or lowercase letter
- allows e abbreviation (suitable for exceptions end errors)
- allows ex abbreviation (suitable for exceptions)
- allows t abbreviation (suitable for throwables)
- prohibits numbered abbreviations like e1 or t2
- prohibits one letter prefixes like pException
- prohibits two letter abbreviations like ie or ee
- prohibits any other characters than letters
Valid:
catch(Exception txD) {}
catch(Exception txf) {}
catch(Exception e) {}
catch(Error e) {}
catch(Exception ex) {}
catch(Throwable t) {}
Invalid:
catch(Exception e2) {}
catch(Exception pExceptions) {}
catch(Exception gh) {}
catch(Exception e_x) {}
ClassDataAbstractionCoupling
Restricts to 7 the number of different classes instantiated within a class when that class is instantiated.
Valid:
class Valid {
private final Item i1 = new Item();
private final Item i2 = new Item();
private final Item i3 = new Item();
private final Item i4 = new Item();
private final Item i5 = new Item();
private final Item i6 = new Item();
private final Item i7 = new Item();
private final Item i8 = new Item();
}
Invalid:
class Invalid {
private final ItemA i1 = new ItemA();
private final ItemB i2 = new ItemB();
private final ItemC i3 = new ItemC();
private final ItemD i4 = new ItemD();
private final ItemE i5 = new ItemE();
private final ItemF i6 = new ItemF();
private final ItemG i7 = new ItemG();
private final ItemH i8 = new ItemH();
}
ClassFanOutComplexity
Restricts the number of other classes that a class can rely on to 20.
While ClassDataAbstractionCoupling
limits the number of classes that are instantiated when the class is, this check counts all fields whether they are assigned a value or not.
ClassTypeParameterName
Restricts class generics parameters to be a single uppercase letter.
Valid:
class Deliverator <A> {}
Invalid:
class Invalidator <a> {}
class Invalidator <BB> {}
class Invalidator <C3> {}
CommentsIndentation
Requires the indentation of comments to match the surrounding code.
Valid:
/**
* This is okay.
*/
int size = 20;
public foo() {
super();
// this is okay
}
public void foo11() {
CheckUtils
.getFirstNode(new DetailAST())
.getFirstChild()
.getNextSibling();
// this is okay
}
Invalid:
/**
* This is NOT okay.
*/
int size = 20;
public foo() {
super();
// this is NOT okay
// this is NOT okay
}
public void foo11() {
CheckUtils
.getFirstNode(new DetailAST())
.getFirstChild()
.getNextSibling();
// this is NOT okay
}
ConstantName
This check cannot be suppressed.
Requires constants (static, final fields) to be all uppercase. Numbers and numbers are permitted but not as the first character.
Valid:
private static final int JACK_CARD = 11;
Invalid:
private static final int ace_card = 1;
private static final int 12_CARD = 12;
CovariantEquals
This check cannot be suppressed.
Checks that classes which define a covariant equals() method also override method equals(Object).
Valid:
class Test {
public boolean equals(Test i) {
return false;
}
public boolean equals(Object i) {
return false;
}
}
Invalid:
class Test {
public boolean equals(Test i) {
return false;
}
}
CyclomaticComplexity
Restricts the cyclomatic complexity of a method to 5. The cyclomatic complexity is a measure of the number of decision points in a method.
A method with no branches has a complexity of 1. For each if
, while
, do
, for
, ?:
, catch
, switch
, case
, &&
and ||
the complexity goes up by 1.
Valid:
void isValid(int a, int b, int c) {
// 1
if (a > b) { // +1 = 2
switch (c) { // +1 = 3
case 1: // +1 = 4
break;
case 2: // +1 = 5
break;
}
}
}
Invalid:
void isInvalid(int a, int b, int c) {
// 1
if (a > b) { // +1 = 2
switch (c) { // +1 = 3
case 1: // +1 = 4
break;
case 2: // +1 = 5
break;
case 3: // +1 = 6
break;
}
}
}
DeclarationOrder
Ensure class elements appear in the correct order.
Valid:
class Valid {
// static
public static int a;
protected static int b;
static int c;
private static int d;
// instance
public int e;
protected int f;
int g;
private int h;
// constructors
Valid() {}
// methods
void foo() {}
}
Invalid:
class Invalid {
protected static int b;
public static int a;
private static int d;
public int e;
static int c;
protected int f;
private int h;
void foo() {}
Valid() {}
int g;
}
DefaultComesLast
Check that the default
is after all the case
s in a switch
statement.
Valid:
switch (a) {
case 1:
break;
case 2:
break;
default:
break;
}
Invalid:
switch (a) {
case 1:
break;
default:
break;
case 2:
break;
}
DesignForExtension
Judicous use of @SuppressWarnings("designdorextension")
is recommended for this check.
This check is primarily intended for use in library modules rather than applications.
Classes that are deemed by their designer to be 'designed for extension', must take steps to prevent a subclass from breaking the class's behaviour by overriding methods incorrectly. This can be done through a combination of:
- Defining 'hook' methods with empty implementations that subclasses override to add their own behaviour
- Marking methods that are non-private and non-static as abstract or final
See the official Checkstyle documentation for more details and Effective Java, 2nd Edition by Josh Bloch: Item 17: Design and document for inheritance or else prohibit it.
EmptyBlock
Checks for empty blocks.
Valid:
if (a >b) {
doSomething();
}
Invalid:
if (a > b) {
}
EmptyCatchBlock
Checks that catch
blocks are not empty, or are commented with the word expected
or ignore
.
Valid:
try {
something();
} catch (Exception e) {
// ignore
}
Invalid:
try {
something();
} catch (Exception e) {
// do nothing
}
EmptyForInitializerPad
Checks that there is no padding in an empty for
loop initialiser.
Valid:
for (; i < j ; i++) {}
Invalid:
for ( ; i < j ; i++) {}
EmptyForIteratorPad
Checks that there is no padding in an empty for
loop iterator.
Valid:
for (Iterator i = list.getIterator(); i.hasNext() ;) {}
Invalid:
for (Iterator i = list.getIterator(); i.hasNext() ; ) {}
EmptyLineSeparator
Checks that there are blank lines between header, package, import blocks, field, constructors, methods, nested classes, static initialisers and instance initialisers.
Valid:
/**
* Licence header.
*/
package net.kemitix.foo;
import ...;
import ...;
class Foo {
private int a;
private int b;
Foo() {}
Foo(int a, int b) {}
int getA() {}
int getB() {}
class Bar {
}
}
Invalid:
/**
* Licence header.
*/
package net.kemitix.foo;
import ...;
import ...;
class Foo {
private int a;
private int b;
Foo() {}
Foo(int a, int b) {}
int getA() {}
int getB() {}
class Bar {
}
}
EmptyStatement
Checks for empty statements. An empty statement is a standalone semicolon (;).
Valid:
doSomething();
Invalid:
doSomething();;
EqualsAvoidNull
Checks that string literals are on the left side in an equals()
comparison.
Valid:
String nullString = null;
"value".equals(nullString);
Invalid:
String nullString = null;
nullString.equals("value");
EqualsHashCode
This check cannot be suppressed.
Checks that when a class overrides the equals()
method, that it also overrides the hashCode()
method.
ExecutableStatementCount
Limits the number of executable statements in a method to 30.
ExplicitInitialization
Checks that fields are not being explicitly initialised to their already default value.
Valid:
class Valid {
private int foo;
private Object bar;
}
Invalid:
class Invalid {
private int foo = 0;
private Object bar = null;
}
FallThrough
Checks that when a case
in a switch
statement falls through (i.e. doesn't end with break;
) that the fall through is documented with a comment.
Valid:
switch (i) {
case 0:
i++; // fall through
case 1:
i++;
// falls through
case 2:
case 3:
case 4: { i++ } // fallthrough
case 5:
i++;
/* fallthrou */
case 6:
i++;
break;
}
Invalid:
switch (i) {
case 0:
i++;
case 1:
i++;
case 2:
case 3:
case 4: { i++ }
case 5:
i++;
case 6:
i++;
break;
}
FileLength
Checks that each file has no more than 2000 lines.
FileTabCharacter
Checks that there are no tab characters in the source files.
FinalClass
Checks that classes which have only private constructors are also declared as final
. These classes can't be extended by a subclass as they can't call super()
from their constructors.
Valid:
final class Valid {
private Valid() {}
}
Invalid:
class Invalid {
private Invalid() {}
}
FinalLocalVariable
Checks that local variables are final
if they are never modified after declaration.
FinalParameters
Parameters to a method must be final
.
Valid:
void foo(final int a) {}
Invalid:
void foo(int a) {}
GenericWhitespace
Checks that the angle brackets around Generics parameters have the correct whitespace padding:
Valid:
public void <K, V extends Number> boolean foo(K, V) {}
class name<T1, T2, ..., Tn> {}
OrderedPair<String, Box<Integer>> p;
boolean same = Util.<Integer, String>compare(p1, p2);
Pair<Integer, String> p1 = new Pair<>(1, "apple");
List<T> list = ImmutableList.Builder<T>::new;
sort(list, Comparable::<String>compareTo);
Header
Checks that all *.java
source files begin with the contents of the LICENSE.txt
file.
HiddenField
Checks that a local variable or parameter in a method doesn't have the same name as a field. Doesn't apply in constructors or setters.
Valid:
class Foo {
private int a;
Foo(int a) {
this.a = a;
}
setA(int a) {
this.a = a;
}
}
Invalid:
class Bar {
private int b;
void baz(int b) {
// ...
}
}
HideUtilityClassConstructor
Classes that only have static fields or methods should not have a public constructor. This includes the default constructor.
Valid:
final class StringUtils {
private Utils() {}
private static int count(chat c, String s) {}
}
class StringUtils {
protected Utils() {
throw new UnsupportedOperationException();
}
private static int count(chat c, String s) {}
}
Invalid:
class StringUtils {
private static int count(chat c, String s) {}
}
IllegalCatch
Prevent the following types from being in a catch
statement:
- java.lang.Exception
- java.lang.Throwable
- java.lang.RuntimeException
Valid:
try {
doSomething();
} catch (SpecificException e) {
// log
}
Invalid:
try {
doSomething();
} catch (Exception e) {
// log
}
IllegalImport
Prevent import
ing from the sun.*
packages.
Invalid:
import sun.security.provider.Sun;
IllegalThrows
Prevent the following types from being throw
n:
- java.lang.Exception
- java.lang.Throwable
- java.lang.RuntimeException
Valid:
throw new SpecificException("error");
Invalid:
throw new RuntimeException("boom!");
IllegalToken
Checks that labels are not used.
IllegalType
Prevents use of implementation classes as variables, parameters or method returns. Use the interfaces instead.
Prevents variables, parameters and method returns from being any of the following:
- java.util.ArrayDeque
- java.util.ArrayList
- java.util.EnumMap
- java.util.EnumSet
- java.util.HashMap
- java.util.HashSet
- java.util.IdentityHashMap
- java.util.LinkedHashMap
- java.util.LinkedHashSet
- java.util.LinkedList
- java.util.PriorityQueue
- java.util.TreeMap
- java.util.TreeSet
Valid:
Set<String> getNames();
Invalid:
HashSet<String> getNames();
InnerAssignment
Checks for assignments within an expressions. However, it still allows assignment in a while loop clause.
Valid:
while((line = reader.readLine()) != null) {
}
Invalid:
String s = Integer.toString(i = 2);
InnerTypeLast
Inner classes must appear at the bottom of a class, below fields and methods.
InterfaceIsType
An interface
must define methods, not just constants.
Valid:
interface Foo {
static final String "Foo!!";
getBar();
}
Invalid:
interface Foo {
static final String "Foo!!";
}
InterfaceTypeParameterName
Checks that the type parameters for an interface are a single uppercase letter.
Valid:
interface <T> Portable {}
Invalid:
interface <Type> Portable {}
JavadocMethod
Checks that all public, protected and package methods have a Javadoc block, that all @throws
tags are used. Basic setters and getters do not require javadoc.
JavadocPackage
Checks that each package has a package-info.java
file.
JavadocParagraph
Checks that paragraphs in Javadoc blocks are wrapped in <p>
elements and have blank lines between paragraphs. This first paragraph does not need the <p>
elements.
JavadocStyle
Checks the formatting of the Javadoc blocks. See the official Checkstyle documentation for all the checks that are applied.
JavadocType
Checks the format for Javadoc for classes and enums. Javadoc must be present, not have any unknown tags and not missing any @param
tags. The @author
tag must have a name and, in brackets, an email address.
JavaNCSS
Restricts the NCSS score for methods, classes and files to 40, 1200 and 1600 respectively. The NCSS score is a measure of the number of statements within a scope.
Too high an NCSS score suggests that the method or class is doing too much and should be decomposed into smaller units.
LeftCurly
Checks that the left curly brace ('{') is placed at the end of the line. Does not check enums.
Valid:
class Foo {
}
Invalid:
class Bar
{
}
LineLength
Limits the line length to 120 characters.
Doesn't check package or import lines.
LocalFinalVariableName
Checks the format of local, final
variable names, including catch
parameters.
Identifiers must match ^[a-z][a-zA-Z0-9]*$
.
LocalVariableName
Checks the format of local, non-final
variable names.
Identifiers must match ^[a-z][a-zA-Z0-9]*$
.
MagicNumber
Checks that numeric literals are defined as constants. Being constants they then have a name that aids in making them non-magical.
The numbers -1, 0, 1 and 2 are not considered to be magical.
Valid:
static final int SECONDS_PER_DAY = 24 * 60 * 60;
static final Border STANDARD_BORDER = BorderFactory.createEmptyBorder(3, 3, 3, 3);
Invalid
String item = getItem(200);
MemberName
Checks the format of non-static field names.
Identifiers must match ^[a-z][a-zA-Z0-9]*$
.
MethodCount
Restricts the number of methods in a type to 30.
MethodLength
Restricts the number of lines in a method to 60. Include blank lines and single line comments. You should be able to see an entire method without needing to scroll.
MethodName
Checks the format of method names.
Identifiers must match ^[a-z][a-zA-Z0-9]*$
.
MethodParamPad
Checks that the padding between the method identifier and the left parenthesis is on the same line and doesn't have a space in-between.
Valid:
void getInstance();
Invalid:
void getInstance ();
void getValue
();
MethodTypeParameterName
Restricts method generics parameters to be a single uppercase letter.
Valid:
List<A> getItems() {}
Invalid:
List<a> getItems() {}
List<BB> getItems() {}
List<C3> getItems() {}
MissingDeprecated
Both the @Deprecated
annotation and the Javadoc tag @deprecated
must be used in pairs.
Valid:
/**
* Foo.
*
* @deprecated
*/
@Deprecated
void foo() {}
Invalid:
/**
* Foo.
*/
@Deprecated
void foo() {}
/**
* Bar.
*
* @deprecated
*/
void bar() {}
MissingSwitchDefault
Checks that switch
statement has a default
case.
Valid:
switch (foo) {
case 1:
//
break;
case 2:
//
break;
default:
throw new IllegalStateExcetion("Foo: " + foo);
}
Invalid:
switch (foo) {
case 1:
//
break;
case 2:
//
break;
}
ModifiedControlVariable
Checks that the control variable in a for
loop is not modified inside the loop.
Invalid:
for (int i = 0; i < 1; i++) {
i++;
}
ModifierOrder
Check that modifiers are in the following order:
public
protected
private
abstract
static
final
transient
volatile
synchronized
native
strictfp
Type annotations are ignored.
MultipleStringLiterals
Checks for multiple occurrences of the same string literal within a single file. Does not apply to empty strings ("").
Invalid:
String fooFoo = "foo" + "foo";
MultipleVariableDeclarations
Checks that each variable is declared in its own statement and line.
Valid:
int a;
int b;
Invalid:
int a, b;
MutableException
Checks that Exception
classes are immutable. However, you can still call setStackTrace
.
Classes checked are those whose name ends with the following. Or that the class they extend does.
Exception
Error
Throwable
NeedBraces
Check that code blocks are surrounded by braces.
Valid:
if (obj.isValid()) {
return true;
}
while (obj.isValid()) {
return true;
}
do {
this.notify();
} while (o != null);
for (int i = 0; ;) {
this.notify();
}
Invalid:
if (obj.isValid()) return true;
while (obj.isValid()) return true;
do this.notify(); while (o != null);
for (int i = 0; ;) this.notify();
NestedForDepth
Checks that for
loops are not nested more than 1 deep.
Valid:
for (int i = 0; i < 1; i++) { // depth 0
for (int j = 0; j < 1; j++) { // depth 1
//
}
}
Invalid:
for (int i = 0; i < 1; i++) { // depth 0
for (int j = 0; j < 1; j++) { // depth 1
for (int k = 0; j < 1; k++) { // depth 2!
//
}
}
}
NestedIfDepth
Checks that if
blocks are not nested more than 1 deep.
Valid:
if (isValid()) { // depth 0
if (isExpected()) { // depth 1
doIt();
}
}
Invalid:
if (isValid()) { // depth 0
if (isExpected()) { // depth 1
if (isNecessary()) { // depth 2!
doIt();
}
}
}
NestedTryDepth
Checks that try
blocks are not nested.
Valid:
try {
doSomething();
doSomeOtherThing();
} catch (SomeException se) {
// handle it
} catch (OtherExceptions oe) {
// handle it
}
Invalid:
try {
doSomething();
try {
doSomeOtherThing();
} catch (OtherExceptions oe) {
// handle it
}
} catch (SomeException se) {
// handle it
}
NewlineAtEndOfFile
Checks that files end with a line-feed character, (i.e. unix-style line ending).
NoClone
This check cannot be suppressed.
Checks that the clone()
method from Object
has not been overridden. Use a copy constructor, or better yet, a static factory method.
See Effective Java, 2nd Edition by Josh Bloch: Item 11: Override clone judiciously.
NoFinalizer
Checks that the finalize()
method from Object
has not been overridden.
See Effective Java, 2nd Edition by Josh Bloch: Item 7: Avoid finalizers.
NoLineWrap
Prevents wrapping of package
and import
statements.
NonEmptyAtclauseDescription
Checks that the Javadoc clauses @param
, @return
, @throws
and @deprecated
all have descriptions.
Valid:
/**
* Foo.
*
* @returns the foo
*/
Invalid:
/**
* Foo.
*
* @returns
*/
NoWhitespaceAfter
Checks that there is no whitespace after the array init ('{'), prefix increment ('++'), prefix decrement ('--'), bitwise complement ('~'), logical complement ('!'), array declaration ('[' in int[] a;
) or array index operator ('[' in a[2]
).
Valid:
int[] y = {1, 2};
++i;
--i;
int j = -1;
int k = +1;
int l = ~2;
boolean state = !isReady();
int b = o.getValue();
int[] a;
int d = a[2];
Invalid:
int[] y = { 1, 2 };
++ i;
-- i;
int j = - 1;
int k = + 1;
int l = ~ 2;
boolean state = ! isReady();
int b = o. getValue();
int[ ] a;
int d = a[ 2];
NoWhitespaceBefore
Checks that there is no whitespace before the comma operator (','), statement terminator (';'), postfix increment ('++') or postfix decrement ('--').
Valid:
int y = {1, 2};
doSomething();
i++;
i--;
Invalid:
int y = {1 , 2};
doSomething() ;
i ++;
i --;
NPathComplexity
Checks that the NPATH score (number of paths) through a method is no more than 5. This is similar to Cyclomatic Complexity.
OneStatementPerLine
Checks that there is only one statement per line.
Valid:
doSomething();
doSomethingElse();
Invalid:
doSomething(); doSomethingElse();
OneTopLevelClass
This check cannot be suppressed.
Checks that each source file contains only one top-level class, interface or enum.
OperatorWrap
Checks that when wrapping a line on an operator that the operator appears on the new line.
Valid:
int answer = getTheAnswerToLife() + getTheAnswerToTheUniverse()
+ getTheAnswerToEverything();
Invalid:
int answer = getTheAnswerToLife() + getTheAnswerToTheUniverse() +
getTheAnswerToEverything();
OuterTypeFilename
This check cannot be suppressed.
Checks that the source filename matches the name of the top-level class. e.g. class Foo {}
is in file Foo.java
.
OverloadMethodsDeclarationOrder
Checks that overload methods are grouped together in the source file.
PackageAnnotation
Checks that package level annotations are in the package-info.java
file.
PackageDeclaration
This check cannot be suppressed.
Checks that the class has a package
definition.
PackageName
Checks the format of package names.
Identifiers must match ^[a-z]+(\.[a-z]+)*$
.
ParameterName
Checks the format of method parameter names, including catch
parameters.
Identifiers must match ^[a-z][a-zA-Z0-9]*$
.
ParameterNumber
Restricts the number of parameters in a method or constructor to 7. Overridden methods are not checked as there may be no access to change the super method.
ParenPad
Checks that there are no spaces padding parentheses.
Valid:
doSomething();
doSomethingElse(5);
Invalid:
doSomething( );
doSomethingElse( 5);
doSomethingElse(5 );
RedundantModifier
Checks for redundant modifiers. Checks for:
- Interface and annotation definitions.
- Final modifier on methods of final and anonymous classes.
- Inner interface declarations that are declared as static.
- Class constructors.
- Nested enum definitions that are declared as static.
RequireThis
Checks that references to instance fields where a parameter name overlaps are qualified by this.
.
ReturnCount
Restricts methods to have at most 2 return
statements in non-void methods, and at most 1 in void methods.
Valid:
int getNumber(int a) {
if (a > 1) {
return a;
}
return 0;
}
void getName(int a) {
String name = "default";
if (a > 1) {
name = "Bob";
}
return name;
}
Invalid:
int getNumber(int a) {
if (a > 1) {
return a;
}
if (a < 2) {
return a * a;
}
return 0;
}
void getName(int a) {
if (a > 1) {
return "Bob";
}
return "default";
}
RightCurly
Checks that the right curly brace ('}') is placed on the same line as the next part of a multi-block statement (e.g. try-catch-finally, if-then-else).
Valid:
try {
//
} catch (Exception e) {
//
} finally {
//
}
if (a > 0) {
//
} else {
//
}
Invalid:
try {
//
}
catch (Exception e) {
//
}
finally {
//
}
if (a > 0) {
//
}
else {
//
}
if (a > 0) {
//
} a = 2;
public long getId() {return id;}
SeparatorWrap
Checks the line wrapping around separators.
- The comma separator (',') should be at the end of the line.
- The dot separator ('.') should be on the new line.
Valid:
doSomething(alpha, beta,
gamma);
doSomethingElse().stream()
.forEach(System.out::println);
Invalid:
doSomething(alpha, beta
, gamma);
doSomethingElse().stream().
forEach(System.out::println);
SimplifyBooleanExpression
Checks for overly complicated boolean expressions. Checks for code like b == true
, b || true
, !false
, etc.
Valid:
if (b) {}
if (true) {}
Invalid:
if (b == true) {}
if (b || true) {}
if (!false) {}
SimplifyBooleanReturn
Checks for overly complicated boolean return
statements.
Valid:
return !valid();
Invalid:
if (valid()) {
return false;
} else {
return true;
}
SingleSpaceSeparator
Checks that non-whitespace characters on the same line are separated by no more than one whitespace.
Valid:
if (a < 0) {}
public long toNanos(long d) { return d; };
Invalid:
if (a < 0) {}
public long toNanos(long d) { return d; };
StaticVariableName
Checks the format of static
, non-final
variable names.
Identifiers must match ^[a-z][a-zA-Z0-9]*$
.
StringLiteralEquality
Checks that string literals are not used with ==
or !=
.
Valid:
if ("something".equals(x)) {}
Invalid:
if (x == "something") {}
SuppressWarnings
Prevents the use of @SuppressWarnings
for the following checks:
- ConstantName
- CovariantEquals
- EqualsHashCode
- NoClone
- OneTopLevelClass
- OuterTypeFilename
- PackageDeclaration
- TypeName
- VisibilityModifier
SuppressWarningsHolder
Used by Checkstyle to hold the checks to be suppressed from @SuppressWarnings(...)
annotations.
ThrowsCount
Restricts non-private methods to only throws
4 distinct Exception types. Exceptions should be hierarchical to allow catching suitable root Exceptions.
See Effective Java, 2nd Edition, Chapter 9: Exceptions
Valid:
void doSomething() throws IllegalStateException, DowsingServiceException,
BalancedBudgetException, ManagementInterferanceException {}
Invalid:
void doSomething() throws IllegalStateException,
DowsingNotPermittedException, DowsingServiceNotReadyException,
BalancedBudgetException, ManagementInterferanceException {}
TodoComment
Checks for remaining TODO
and FIXME
comments left in code. Their presence indicates that the program isn't finished yet.
TrailingComment
Checks for comments at the end of lines.
Valid:
// comment on line by itself
// comment after white space
if (a < 1) {
//
} // comment on closing brace
int[] a = new int[2](
1, 2
); // comment on closing parenthesis of statement
Invalid:
int a = 1; // comment in line with statement
if (a < 1) { // comment on line with if statement
//
}
int[] a = new int[2](
1, // first value - invalid comment
2 // second value - also invalid comment
);
Translation
Checks that all messages*.properties
files all have the same set of keys.
TypecastParenPad
Checks that there are no spaces within the typecasting parentheses.
Valid:
String s = (String) list.get(2);
Invalid:
String s = (String ) list.get(2);
String s = ( String) list.get(2);
String s = ( String ) list.get(2);
TypeName
This check cannot be suppressed.
Checks the format of class
, interface
, enum
identifiers, including annotations.
Identifiers must match ^[A-Z][a-zA-Z0-9]*$
.
UncommentedMain
Checks for public static void main()
methods that may have been left over from testing. Allowed in classes whose names end in Main
or Application
.
UniqueProperties
Checks *.properties
files for duplicate property keys.
UnnecessaryParentheses
Checks for the use of unnecessary parentheses.
Valid:
if (a < 1) {}
Invalid:
if ((a < 1)) {}
UnusedImports
Checks for unused imports. Does not inspect wildcard imports, which should be blocked by AvoidStarImport anyway.
Imports are unused if:
- They are not referenced in the file.
- It duplicates another import.
- It import from the
java.lang
package. - It imports a class from the same package.
- It is only references from the Javadoc.
UpperEll
Checks that long
numeric literal values are marked by an upper-case ell ('L'). The lower-case ell ('l') can be mistaken for the numeral one ('1').
Valid:
long id = 12345L;
Invalid:
long id = 12345l;
VariableDeclarationUsageDistance
Checks that a variable declaration and its first usage are not more than 3 lines. Blocks of initialisation methods don't count toward this total.
See the official Checkstyle documentation for examples.
VisibilityModifier
This check cannot be suppressed.
Checks the visibility of class members to help enforce encapsulation. Only static final
fields, immutable (see list below) fields or field with special annotation (see list below), may be public.
The following are considered immutable when final
, and can be public
:
- java.lang.String
- java.lang.Integer
- java.lang.Byte
- java.lang.Character
- java.lang.Short
- java.lang.Boolean
- java.lang.Long
- java.lang.Double
- java.lang.Float
- java.lang.StackTraceElement
- java.math.BigInteger
- java.math.BigDecimal
- java.io.File
- java.util.Locale
- java.util.UUID
- java.net.URL
- java.net.URI
- java.net.Inet4Address
- java.net.Inet6Address
- java.net.InetSocketAddress
Fields with the following annotations may be public
:
- org.junit.Rule
- org.junit.ClassRule
- com.google.common.annotations.VisibleForTesting
Valid:
class Foo {
public final Long id;
public final String name;
private String description;
@VisibleForTesting
public State state;
Foo(final Long id, final String name) {
this.id = id;
this.name = name;
}
}
Invalid:
class Foo {
public Long id;
public String name;
private String description;
public State state;
Foo(final Long id, final String name) {
this.id = id;
this.name = name;
}
}
WhitespaceAfter
Checks that commas (','), statement terminators (';') and typecasts are all followed by a space.
Valid:
doSomething(1, 2, 3);
if (a > 1) { return true; }
String name = (String) list.get(9);
Inalid:
doSomething(1,2,3);
if (a > 1) { return true;}
String name = (String)list.get(9);
WhitespaceAround
Checks that tokens are surrounded by whitespace.
Sevntu
AvoidConstantAsFirstOperandInCondition
Checks that condition expressions don't become less readable by attempting to use a constant on the left-hand-side of a comparison.
Valid:
if (a == 12) {}
Invalid:
if (12 == a) {}
AvoidHidingCauseException
Ensures that an exception is re-thrown properly and is not swallowed by a catch
block.
Valid:
try {
doSomething();
} catch (MyException e) {
throw new MyOtherException(e);
}
Invalid:
try {
doSomething();
} catch (MyException e) {
throw new MyOtherException();
}
AvoidNotShortCircuitOperatorsForBoolean
Prevents the use of boolean operators that don't allow short-circuiting the expression. (e.g. '|', '&', '|=' and '&=')
Valid:
if ((a < b) || (b > getExpensiveValue())) {}
Invalid:
if ((a < b) | (b > getExpensiveValue())) {}
ConfusingCondition
Checks that the expression with the if
condition in an if-then-else
statement is not negated.
Valid:
if (isValid()) {
handleValidCondition();
} else {
handleInvalidCondition();
}
Invalid:
if (!isValid()) {
handleInvalidCondition();
} else {
handleValidCondition();
}
ConstructorWithoutParams
Exception class constructors must accept parameters for message and/or cause. This check is applied to classes whose name ends with Exception
.
DiamondOperatorForVariableDefinition
Checks that the diamond operator is used where possible.
Valid:
Map<Long, String> idTable = new HashMap<>();
Invalid:
Map<Long, String> idTable = new HashMap<Long, String>();
EitherLogOrThrow
Checks that when an exception is caught, that if it is logged then it is not also re-thrown. Log or throw; one or the other or neither, but not both.
Accepts java.util.logging.Logger
and org.slf4j.Logger
.
EnumValueName
Forces Enum values to be all upper-case when the enum has no methods or fields, otherwise the values must must be either all upper-case or must match the class naming format.
Valid:
enum ValidConstants {
ALPHA, BETA;
}
enum ValidClassLike {
Alpha("a"),
Beta("b");
private String name;
ValidClassLike(String name) {
this.name = name;
}
}
Invalid:
enum InvalidConstants {
alpha, Beta;
}
enum InvalidClassLike {
alpha("a"),
beta("b");
private String name;
InvalidClassLike(String name) {
this.name = name;
}
}
ForbidCCommentsInMethods
Prevents the use of /* C-style */
comments inside methods.
Valid:
void doSomething() {
// a comment
}
Invalid:
void doSomething() {
/* invalid */
}
ForbidReturnInFinallyBlock
Prevent the use of a return
statement in the finally
block.
Invalid:
try {
doSomething();
{ catch (IOException e) {
// log error
} finally (
return true; // invalid
}
ForbidWildcardAsReturnType
Prevents declaring a method from returning a wildcard type as its return value.
Valid:
<E> List<E> getList() {}
Invalid:
<E> List<? extends E> getList() {}
LogicConditionNeedOptimization
Prevent the placement of variables or fields after methods in an expression.
Valid:
if (property && getProperty()) {}
Invalid:
if (getProperty() && property) {}
MapIterationInForEachLoop
Checks for unoptimised iterations over Map
s. Check use of map.values()
, map.keySet()
and map.entrySet()
against the use of the iterator produced to verify if another could be better.
NameConventionForJunit4TestClasses
Checks the names of JUnit test classes. Classes checked are those that have at least one method annotated with Test
or org.junit.Test
.
Test class names must match: .+Test\\d*|.+Tests\\d*|Test.+|Tests.+|.+IT|.+ITs|.+TestCase\\d*|.+TestCases\\d*
NestedSwitch
Checks that switch
statements are not nested within one another.
Valid:
void doSomething(int a, int b) {
switch(a) {
case 1:
doMore(b);
break;
case 2:
// ..
}
}
}
void doMore(int b) {
switch(b) {
case 1:
//
case 2:
//
}
}
Invalid:
void doSomething(int a, int b) {
switch(a) {
case 1:
switch(b) {
case 1:
//
case 2:
//
}
break;
case 2:
// ..
}
}
}
NoMainMethodInAbstractClass
Prevents a main
method from existing in an abstract
class.
NumericLiteralNeedsUnderscore
Checks that numeric literals use underscores ('_') if over a certain length.
-
Decimals
- 7 or more digits must use the underscore
- No more than 3 digits between underscores
-
Hex
- 5 or more digits must use the underscore
- No more than 4 digits between underscores
-
Binary
- 9 or more digits must use the underscore
- No more than 8 digits between underscores
OverridableMethodInConstructor
Prevents calls to overridable methods from constuctors including other methods that perform the same functions. (i.e. Cloneable.clone()
and Serializable.readObject()
)
Invalid:
abstract class Base {
Base() {
overrideMe();
}
}
class Child extends Base {
final int x;
Child(int x) {
this.x = x;
}
void overrideMe() {
System.out.println(x);
}
}
new Child(42); // prints "0"
PublicReferenceToPrivateType
Checks that a type is not exposed outside its declared scope.
Invalid:
public class OuterClass {
public InnerClass inner = new InnerClass();
public SiblingClass sibling = new SiblingClass();
public InnerClass getValue() { return new InnerClass(); }
public SiblingClass getSibling() { return new SiblingClass(); }
private class InnerClass {}
}
class SiblingClass {}
RedundantReturn
Checks for redundant return statements.
Invalid:
HelloWorld() {
doStuff();
return;
}
void doStuff() {
doMoreStuff();
return;
}
ReturnBooleanFromTernary
Ternary statements shouldn't have Boolean
values as results.
Valid:
Boolean set = isSet() ? True : False;
Boolean notReady = isReady() ? False : True;
Invalid:
Boolean set = isSet();
Boolean notReady = !isReady();
ReturnNullInsteadOfBoolean
The Boolean
type is meant to only represent a binary state: TRUE or FALSE. It is not a ternary value: TRUE, FALSE, null.
Invalid:
Boolean isEnabled() {
if (level > 0) {
return True;
}
if (level < 0) {
return False;
}
return null;
}
SimpleAccessorNameNotation
Checks that setters and getters follow the normal setField(), getField() and isField() pattern, where 'Field' is the name of the field being accessed.
SingleBreakOrContinue
Checks that there is at most one continue
or break
statement within a looping block (e.g. for
, while
, ...)
TernaryPerExpressionCount
Checks that there is at most one ternary statments (?:
) within an expression.
Invalid:
String x = value != null ? "A" : "B" + value == null ? "C" : "D"
UniformEnumConstantName
Checks that all the values of an enum
follow the same naming pattern.
Valid:
public enum EnumOne {
FirstElement, SecondElement, ThirdElement;
}
public enum EnumTwo {
FIRST_ELEMENT, SECOND_ELEMENT, THIRD_ELEMENT;
}
Invalid:
public enum EnumThree {
FirstElement, SECOND_ELEMENT, ThirdElement;
}
UselessSingleCatch
Checks for catch blocks that are useless. i.e. that catch al exceptions and then just rethrow them.
Invalid:
try {
doSomething();
} catch (Exception e) {
throw e;
}
UselessSuperCtorCall
Checks for useless calls the the super()
method in constructors.
Invalid:
class Dummy {
Dummy() {
super();
}
}
class Derived extends Base {
Derived() {
super();
}
}
Disabled Checks
These checks are not enabled. Notes are included for each explaining why.
Checkstyle
ArrayTrailingComma
Couldn't get my IDE's (IntelliJ) code style to match.
IllegalInstantiation
Not really suitable for a template ruleset as it requires an explicit list of classes to apply to.
IllegalTokenText
Generic rule; doesn't embody a 'quality' check.
ImportControl
Generic rule; doesn't embody a 'quality' check.
ImportOrder
Generic rule; doesn't embody a 'quality' check.
Indentation
Couldn't get my IDE's (IntelliJ) code style to match.
JavadocTagContinuationIndentation
Couldn't get my IDE's (IntelliJ) code style to match.
JavadocVariable
Member variables should usually be named such that it is clear what they are. Comments for clarification should be the exception.
MissingCtor
Would not see constructors created using Lombok's @NoArgsConstructor
.
MissingOverride
The javadoc compiler automatically inherits the javadoc from the overridden method, it doesn't need to be told to do so.
OuterTypeNumber
Already covered by the OneTopLevelClass check.
ParameterAssignment
FinalParameters already protects against assigning values to parameters.
RedundantImport
UnusedImports performs all the same checks and more.
Checks for redundant import
s. Checks for duplicates, imports from the java.lang
package or from the current package.
Regexp
Generic rule; doesn't embody a 'quality' check.
RegexpHeader
Generic rule; doesn't embody a 'quality' check.
RegexpMultiline
Generic rule; doesn't embody a 'quality' check.
RegexpOnFilename
Generic rule; doesn't embody a 'quality' check.
RegexpSingleline
Generic rule; doesn't embody a 'quality' check.
RegexpSingleline
Generic rule; doesn't embody a 'quality' check.
SingleLineJavadoc
I don't use single line javadoc blocks.
SummaryJavadoc
Generic rule; doesn't embody a 'quality' check.
SuperClone
Overridding the clone()
method is not allowed by the NoClone check.
SuperFinalize
NoFinalizer prevents use of finalize()
.
WriteTag
Generic rule; doesn't embody a 'quality' check.
Sevntu
As the sevntu check are considered experimental not all those that are not enabled are listed here. Only where they are disabled due to a conflict with my 'style' or there is another irreconcilable difference that prevents them from being enabled, will they be documented to prevent repeated investigations.
AvoidConditionInversion
Should already be covered by SimplifyBooleanExpression.
TODO: disable
AvoidDefaultSerializableInInnerClasses
TODO: enable
AvoidModifiersForTypes
Generic rule; doesn't embody a 'quality' check.
CauseParameterInException
Should already be covered by AvoidHidingCauseException.
ChildBlockLength
Appears to be broken as of 1.21.0
.
CustomDeclarationOrder
The DeclarationOrder check already imposes an order for class elements.
EmptyPublicCtorInClass
TODO: enable
FinalizeImplementation
TODO: enable
ForbidAnnotation
Generic rule; doesn't embody a 'quality' check.
ForbidCertainImports
Generic rule; doesn't embody a 'quality' check.
ForbidInstantiation
Generic rule; doesn't embody a 'quality' check.
ForbidThrowAnonymousExceptions
IllegalThrows performs a similar check.
HideUtilityClassConstructor
See HideUtilityClassConstructor.
IllegalCatchExtended
See IllegalCatch.
InnerClass
See InnerTypeLast.
InterfaceTypeParameterName
See InterfaceTypeParameterName.
LineLengthExtended
See LineLength
MultipleStringLiteralsExtended
See MultipleStringLiteralsExtended.
MultipleVariableDeclarationsExtended
See MultipleVariableDeclarations.
RequiredParameterForAnnotation
Generic rule; doesn't embody a 'quality' check.
ReturnCountExtended
See ReturnCount.
StaticMethodCandidate
Can't handle private methods called by reflection, which may cause issues with Spring and other DI frameworks.
UnnecessaryParenthesesExtended
WhitespaceBeforeArrayInitializer
TODO: enable