` elements and have blank lines between paragraphs. This first paragraph does not need the `
` elements. #### [JavadocStyle](http://checkstyle.sourceforge.net/config_javadoc.html#JavadocStyle) Checks the formatting of the Javadoc blocks. See the official [Checkstyle documentation](http://checkstyle.sourceforge.net/config_javadoc.html#JavadocStyle) for all the checks that are applied. #### [JavadocType](http://checkstyle.sourceforge.net/config_javadoc.html#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. > TODO: authorFormat = "^.+ (\S+@[\S.]+)$" - name followed by email in brackets #### [JavaNCSS](http://checkstyle.sourceforge.net/config_metrics.html#JavaNCSS) Restricts the NCSS score for methods, classes and files to 50, 1500 and 2000 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. > TODO: methodMaximum = 40 - reduce by 20% > TODO: classMaximum = 1200 > TODO: fileMaximum = 1600 #### [LeftCurly](http://checkstyle.sourceforge.net/config_blocks.html#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](http://checkstyle.sourceforge.net/config_sizes.html#LineLength) Limits the line length to 80 characters. Doesn't check package or import lines. > TODO: ignorePattern = "^\s\\* .+" exclude javadoc blocks #### [LocalFinalVariableName](http://checkstyle.sourceforge.net/config_naming.html#LocalFinalVariableName) Checks the format of local, `final` variable names, including `catch` parameters. Identifiers must match `^[a-z][a-zA-Z0-9]*$`. #### [LocalVariableName](http://checkstyle.sourceforge.net/config_naming.html#LocalVariableName) Checks the format of local, non-`final` variable names. Identifiers must match `^[a-z][a-zA-Z0-9]*$`. #### [MagicNumber](http://checkstyle.sourceforge.net/config_coding.html#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](http://checkstyle.sourceforge.net/config_naming.html#MemberName) Checks the format of non-static field names. Identifiers must match `^[a-z][a-zA-Z0-9]*$`. #### [MethodCount](http://checkstyle.sourceforge.net/config_sizes.html#MethodCount) Restricts the number of methods in a type to 30. #### [MethodLength](http://checkstyle.sourceforge.net/config_sizes.html#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. > TODO: max = 40 #### [MethodName](http://checkstyle.sourceforge.net/config_naming.html#MethodName) Checks the format of method names. Identifiers must match `^[a-z][a-zA-Z0-9]*$`. #### [MethodParamPad](http://checkstyle.sourceforge.net/config_whitespace.html#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 (); ```` #### [MissingDeprecated](http://checkstyle.sourceforge.net/config_annotation.html#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](http://checkstyle.sourceforge.net/config_coding.html#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](http://checkstyle.sourceforge.net/config_coding.html#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++; } ```` > TODO: skipEnhancesForLoopVariable = true #### [ModifierOrder](http://checkstyle.sourceforge.net/config_modifier.html#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](http://checkstyle.sourceforge.net/config_coding.html#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](http://checkstyle.sourceforge.net/config_coding.html#MultipleVariableDeclarations) Checks that each variable is declared in its own statement and line. Valid: ```` int a; int b; ```` Invalid: ```` int a, b; ```` #### [MutableException](http://checkstyle.sourceforge.net/config_design.html#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](http://checkstyle.sourceforge.net/config_blocks.html#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](http://checkstyle.sourceforge.net/config_coding.html#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](http://checkstyle.sourceforge.net/config_coding.html#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](http://checkstyle.sourceforge.net/config_coding.html#NestedTryDepth) Checks that `try` blocks are not nested more than 1 deep. Valid: ```` try { doSomething(); try { doSomeOtherThing(); } catch (OtherExceptions oe) { // handle it } } catch (SomeException se) { // handle it } ```` Invalid: ```` try { doSomething(); try { doSomeOtherThing(); } catch (OtherExceptions oe) { // handle it } } catch (SomeException se) { // handle it } ```` > TODO: max = 0 - don't nest try blocks #### [NoClone](http://checkstyle.sourceforge.net/config_coding.html#NoClone) 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. #### [NonEmptyAtclauseDescription](http://checkstyle.sourceforge.net/config_javadoc.html#NonEmptyAtclauseDescription) Checks that the Javadoc clauses `@param`, `@return`, `@throws` and `@deprecated` all have descriptions. Valid: ```` /** * Foo. * * @returns the foo */ ```` Invalid: ```` /** * Foo. * * @returns */ ```` #### [NoWhitespaceAfter](http://checkstyle.sourceforge.net/config_whitespace.html#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]; ```` > TODO: tokens = DOT & allowLineBreaks = false #### [NoWhitespaceBefore](http://checkstyle.sourceforge.net/config_whitespace.html#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](http://checkstyle.sourceforge.net/config_metrics.html#NPathComplexity) Checks that the NPATH score (number of paths) through a method is no more than 200. This is similar to [Cyclomatic Complexity](#cyclomaticcomplexity). > TODO: max = 5 - same as cyclomatic complexity #### [OneStatementPerLine](http://checkstyle.sourceforge.net/config_coding.html#OneStatementPerLine) Checks that there is only one statement per line. Valid: ```` doSomething(); doSomethingElse(); ```` Invalid: ```` doSomething(); doSomethingElse(); ```` #### [OneTopLevelClass](http://checkstyle.sourceforge.net/config_design.html#OneTopLevelClass) Checks that each source file contains only one top-level class, interface or enum. #### [OperatorWrap](http://checkstyle.sourceforge.net/config_whitespace.html#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](http://checkstyle.sourceforge.net/config_misc.html#OuterTypeFilename) Checks that the source filename matches the name of the top-level class. e.g. `class Foo {}` is in file `Foo.java`. #### [OverloadMethodsDeclarationOrder](http://checkstyle.sourceforge.net/config_coding.html#OverloadMethodsDeclarationOrder) Checks that overload methods are grouped together in the source file. #### [PackageDeclaration](http://checkstyle.sourceforge.net/config_coding.html#PackageDeclaration) Checks that the class has a `package` definition. #### [PackageName](http://checkstyle.sourceforge.net/config_naming.html#PackageName) Checks the format of package names. Identifiers must match `^[a-z]+(\.[a-zA-Z_][a-zA-Z0-9_]*)*$`. > TODO: format = `^[a-z]+(\.[a-z]+)*$` - only lowercase letters, no numbers or underscores #### [ParameterName](http://checkstyle.sourceforge.net/config_naming.html#ParameterName) Checks the format of method parameter names, including `catch` parameters. Identifiers must match `^[a-z][a-zA-Z0-9]*$`. #### [ParameterNumber](http://checkstyle.sourceforge.net/config_sizes.html#ParameterNumber) Restricts the number of parameters in a method or constructor to 7. > TODO: ignoreOverriddenMethods = true #### [ParenPad](http://checkstyle.sourceforge.net/config_whitespace.html#ParenPad) Checks that there are no spaces padding parentheses. Valid: ```` doSomething(); doSomethingElse(5); ```` Invalid: ```` doSomething( ); doSomethingElse( 5); doSomethingElse(5 ); ```` #### [RedundantImport](http://checkstyle.sourceforge.net/config_imports.html#RedundantImport) Checks for redundant `import`s. Checks for duplicates, imports from the `java.lang` package or from the current package. > TODO: remove - [UnusedImports](#unusedimports) performs all the same checks and more #### [RedundantModifier](http://checkstyle.sourceforge.net/config_modifier.html#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. #### [ReturnCount](http://checkstyle.sourceforge.net/config_coding.html#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](http://checkstyle.sourceforge.net/config_blocks.html#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](http://checkstyle.sourceforge.net/config_whitespace.html#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](http://checkstyle.sourceforge.net/config_coding.html#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](http://checkstyle.sourceforge.net/config_coding.html#SimplifyBooleanReturn) Checks for overly complicated boolean `return` statements. Valid: ```` return !valid(); ```` Invalid: ```` if (valid()) { return false; } else { return true; } ```` #### [SingleSpaceSeparator](http://checkstyle.sourceforge.net/config_whitespace.html#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](http://checkstyle.sourceforge.net/config_naming.html#StaticVariableName) Checks the format of `static`, non-`final` variable names. Identifiers must match `^[a-z][a-zA-Z0-9]*$`. #### [StringLiteralEquality](http://checkstyle.sourceforge.net/config_coding.html#StringLiteralEquality) Checks that string literals are not used with `==` or `!=`. Valid: ```` if ("something".equals(x)) {} ```` Invalid: ```` if (x == "something") {} ```` #### [SuppressWarningsHolder](http://checkstyle.sourceforge.net/config_annotation.html#SuppressWarningsHolder) Used by Checkstyle to hold the checks to be suppressed from `@SuppressWarnings(...)` annotations. #### [ThrowsCount](http://checkstyle.sourceforge.net/config_design.html#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](http://checkstyle.sourceforge.net/config_misc.html#TodoComment) Checks for remaining `TODO` and `FIXME` comments left in code. Their presence indicates that the program isn't finished yet. > TODO: format = "(//\*).*((TODO)|(FIXME))" - only where in comments #### [TrailingComment](http://checkstyle.sourceforge.net/config_misc.html#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 ); ```` #### [TypecastParenPad](http://checkstyle.sourceforge.net/config_whitespace.html#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](http://checkstyle.sourceforge.net/config_naming.html#TypeName) Checks the format of `class`, `interface`, `enum` identifiers, including annotations. Identifiers must match `^[A-Z][a-zA-Z0-9]*$`. #### [UnnecessaryParentheses](http://checkstyle.sourceforge.net/config_coding.html#UnnecessaryParentheses) Checks for the use of unnecessary parentheses. Valid: ```` if (a < 1) {} ```` Invalid: ```` if ((a < 1)) {} ```` #### [UnusedImports](http://checkstyle.sourceforge.net/config_imports.html#UnusedImports) Checks for unused imports. Does not inspect wildcard imports, which should be blocked by [AvoidStarImport](#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](http://checkstyle.sourceforge.net/config_misc.html#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](http://checkstyle.sourceforge.net/config_coding.html#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](http://checkstyle.sourceforge.net/config_coding.html#VariableDeclarationUsageDistance) for examples. #### [VisibilityModifier](http://checkstyle.sourceforge.net/config_design.html#VisibilityModifier) 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](http://checkstyle.sourceforge.net/config_whitespace.html#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](http://checkstyle.sourceforge.net/config_whitespace.html#WhitespaceAround) Checks that tokens are surrounded by whitespace. ### Sevntu TODO [Effective Java]: http://amzn.to/2aSz6GE