Each of these naming modules validates identifiers for particular code elements. Valid identifiers for a naming module are specified by its format property. The value of format is a regular expression for valid identifiers.
Since Checkstyle 5.8
The Check validate abbreviations(consecutive capital letters) length in identifier name, it also allows to enforce camel case naming. Please read more at Google Style Guide to get to know how to avoid long abbreviations in names.
allowedAbbreviationLength specifies how many consecutive capital letters are allowed in the identifier. A value of 3 indicates that up to 4 consecutive capital letters are allowed, one after the other, before a violation is printed. The identifier 'MyTEST' would be allowed, but 'MyTESTS' would not be. A value of 0 indicates that only 1 consecutive capital letter is allowed. This is what should be used to enforce strict camel casing. The identifier 'MyTest' would be allowed, but 'MyTEst' would not be.
| name | description | type | default value | since |
|---|---|---|---|---|
| allowedAbbreviationLength | Indicate the number of consecutive capital letters allowed in targeted identifiers (abbreviations in the classes, interfaces, variables and methods names, ... ). | Integer | 3 | 5.8 |
| allowedAbbreviations | Specify list of abbreviations that must be skipped for checking. Abbreviations should be separated by comma. | String Set | {} | 5.8 |
| ignoreFinal | Allow to skip variables with final modifier. | Boolean | true | 5.8 |
| ignoreStatic | Allow to skip variables with static modifier. | Boolean | true | 5.8 |
| ignoreOverriddenMethods | Allow to ignore methods tagged with @Override annotation (that usually mean inherited name). | Boolean | true | 5.8 |
| tokens | tokens to check | subset of tokens CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF, ANNOTATION_FIELD_DEF, PARAMETER_DEF, VARIABLE_DEF, METHOD_DEF, ENUM_CONSTANT_DEF. | CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF, ANNOTATION_FIELD_DEF, PARAMETER_DEF, VARIABLE_DEF, METHOD_DEF. | 5.8 |
Default configuration
<module name="AbbreviationAsWordInName"/>
To configure to check all variables and identifiers (including ones with the static modifier) and enforce no abbreviations (essentially camel case) except for words like 'XML' and 'URL'.
Configuration:
<module name="AbbreviationAsWordInName">
<property name="tokens" value="VARIABLE_DEF,CLASS_DEF"/>
<property name="ignoreStatic" value="false"/>
<property name="allowedAbbreviationLength" value="0"/>
<property name="allowedAbbreviations" value="XML,URL"/>
</module>
Example:
public class MyClass { // OK
int firstNum; // OK
int secondNUM; // violation, it allowed only 1 consecutive capital letter
static int thirdNum; // OK, the static modifier would be checked
static int fourthNUm; // violation, the static modifier would be checked,
// and only 1 consecutive capital letter is allowed
String firstXML; // OK, XML abbreviation is allowed
String firstURL; // OK, URL abbreviation is allowed
}
To configure to check variables, excluding fields with the static modifier, and allow abbreviations up to 2 consecutive capital letters ignoring the longer word 'CSV'.
Configuration:
<module name="AbbreviationAsWordInName">
<property name="tokens" value="VARIABLE_DEF"/>
<property name="ignoreStatic" value="true"/>
<property name="allowedAbbreviationLength" value="1"/>
<property name="allowedAbbreviations" value="CSV"/>
</module>
Example:
public class MyClass { // OK, ignore checking the class name
int firstNum; // OK, abbreviation "N" is of allowed length 1
int secondNUm; // OK
int secondMYNum; // violation, found "MYN" but only
// 2 consecutive capital letters are allowed
int thirdNUM; // violation, found "NUM" but it is allowed
// only 2 consecutive capital letters
static int fourthNUM; // OK, variables with static modifier
// would be ignored
String firstCSV; // OK, CSV abbreviation is allowed
String firstXML; // violation, XML abbreviation is not allowed
}
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 3.2
Ensures that the names of abstract classes conforming to some regular expression and check that abstract modifier exists.
Rationale: Abstract classes are convenience base class implementations of interfaces, not types as such. As such they should be named to indicate this. Also if names of classes starts with 'Abstract' it's very convenient that they will have abstract modifier.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specify valid identifiers. | Regular Expression | "^Abstract.+$" | 3.2 |
| ignoreModifier | Control whether to ignore checking for the abstract modifier on classes that match the name. | Boolean | false | 5.3 |
| ignoreName | Control whether to ignore checking the name. Realistically only useful if using the check to identify that match name and do not have the abstract modifier. | Boolean | false | 5.3 |
The following example shows how to configure the AbstractClassName to checks names, but ignore missing abstract modifiers:
Configuration:
<module name="AbstractClassName">
<property name="ignoreModifier" value="true"/>
</module>
Example:
abstract class AbstractFirstClass {} // OK
abstract class SecondClass {} // violation, it should match the pattern "^Abstract.+$"
class AbstractThirdClass {} // OK, no "abstract" modifier
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 6.14
Checks that catch parameter names conform to a format specified by the format property.
Default pattern has the following characteristic:
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^(e|t|ex|[a-z][a-z][a-zA-Z]+)$" | 6.14 |
An example of how to configure the check is:
<module name="CatchParameterName"/>
An example of how to configure the check for names that begin with a lower case letter, followed by any letters or digits is:
Configuration:
<module name="CatchParameterName">
<property name="format" value="^[a-z][a-zA-Z0-9]+$"/>
</module>
Example:
public class MyTest {
public void myTest() {
try {
// ...
} catch (ArithmeticException ex) { //OK
// ...
} catch (ArrayIndexOutOfBoundsException ex2) { //OK
// ...
} catch (IOException thirdException) { //OK
// ...
} catch (Exception FourthException) { // violation, the initial letter
// should be lowercase
// ...
}
}
}
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 5.0
Checks that class type parameter names conform to a format specified by the format property.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[A-Z]$" | 5.0 |
An example of how to configure the check is:
<module name="ClassTypeParameterName"/>
An example of how to configure the check for names that are only a single letter is:
Configuration:
<module name="ClassTypeParameterName">
<property name="format" value="^[a-zA-Z]$"/>
</module>
Example:
class MyClass1<T> {} // OK
class MyClass2<t> {} // OK
class MyClass3<abc> {} // violation, the class type parameter
// name should match the regular expression "^[a-zA-Z]$"
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 3.0
Checks that constant names conform to a format specified by the format property. A constant is a static and final field or an interface/annotation field, except serialVersionUID and serialPersistentFields.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$" | 3.0 |
| applyToPublic | Controls whether to apply the check to public member. | Boolean | true | 5.0 |
| applyToProtected | Controls whether to apply the check to protected member. | Boolean | true | 5.0 |
| applyToPackage | Controls whether to apply the check to package-private member. | Boolean | true | 5.0 |
| applyToPrivate | Controls whether to apply the check to private member. | Boolean | true | 5.0 |
An example of how to configure the check is:
<module name="ConstantName"/>
The following configuration apart from names allowed by default allows log or logger:
<module name="ConstantName">
<property name="format"
value="^log(ger)?$|^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$"/>
</module>
Code Example:
class MyClass {
final static int log = 10; // OK
final static int logger = 50; // OK
final static int logMYSELF = 10; // violation, name 'logMYSELF' must match
// pattern '^log(ger)?$|^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$'
final static int loggerMYSELF = 5; // violation, name 'loggerMYSELF' must match
// pattern '^log(ger)?$|^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$'
final static int MYSELF = 100; // OK
final static int myselfConstant = 1; // violation, name 'myselfConstant' must match pattern
// '^log(ger)?$|^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$'
}
The following configuration skip validation on public constant field and protected constant field.
<module name="ConstantName">
<property name="applyToPublic" value="false"/>
<property name="applyToProtected" value="false">
</module>
Code Example:
class MyClass {
public final static int firstConstant = 10; // OK
protected final static int secondConstant = 100; // OK
final static int thirdConstant = 1000; // violation, name 'thirdConstant' must
// match pattern '^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$'
private final static int fourthConstant = 50; // violation, name 'fourthConstant' must match
// pattern '^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$'
}
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 5.8
Checks that interface type parameter names conform to a format specified by the format property.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[A-Z]$" | 5.8 |
An example of how to configure the check is:
<module name="InterfaceTypeParameterName"/>
Code Example:
interface FirstInterface<T> {} // OK
interface SecondInterface<t> {} // violation, name 't' must match pattern '^[A-Z]$'
An example of how to configure the check for names that are only a single letter is:
<module name="InterfaceTypeParameterName">
<property name="format" value="^[a-zA-Z]$"/>
</module>
Code Example:
interface FirstInterface<T> {} // OK
interface SecondInterface<t> {} // OK
interface ThirdInterface<type> {} // violation, name 'type' must
// match pattern '^[a-zA-Z]$'
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 8.11
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[a-z][a-zA-Z0-9]*$" | 8.11 |
An example of how to configure the check is:
<module name="LambdaParameterName"/>
An example of how to configure the check for names that begin with a lower case letter, followed by letters is:
<module name="LambdaParameterName">
<property name="format" value="^[a-z]([a-zA-Z]+)*$"/>
</module>
Example of checking with this config:
public class TestClass {
Function<String, String> function1 = str -> str.toUpperCase().trim();
Function<String, String> function2 = _s -> _s.trim().toUpperCase(); // violation
public boolean testMethod(String sentence) {
return Stream.of(sentence.split(" "))
.map(word -> word.trim())
.anyMatch(Word -> "in".equals(Word)); // violation
}
}
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 3.0
Checks that local final variable names conform to a format specified by the format property. A catch parameter and resources in try statements are considered to be a local, final variables.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[a-z][a-zA-Z0-9]*$" | 3.0 |
| tokens | tokens to check | subset of tokens VARIABLE_DEF, PARAMETER_DEF, RESOURCE. | VARIABLE_DEF, PARAMETER_DEF, RESOURCE. | 3.0 |
An example of how to configure the check is:
<module name="LocalFinalVariableName"/>
An example of how to configure the check for names that are only upper case letters and digits is:
<module name="LocalFinalVariableName">
<property name="format" value="^[A-Z][A-Z0-9]*$"/>
</module>
Code Example:
class MyClass {
void MyMethod() {
try {
final int VAR1 = 5; // OK
final int var1 = 10; // violation, name 'var1' must match pattern "^[A-Z][A-Z0-9]*$"
} catch (Exception ex) {
final int VAR2 = 15; // OK
final int var2 = 20; // violation, name 'var2' must match pattern "^[A-Z][A-Z0-9]*$"
}
}
}
An example of how to configure the check for names of local final parameters and resources in try statements (without checks on variables):
<module name="LocalFinalVariableName">
<property name="format" value="^[A-Z][A-Z0-9]*$"/>
<property name="tokens" value="PARAMETER_DEF,RESOURCE">
</module>
Code Example:
class MyClass {
void MyMethod() {
try(Scanner scanner = new Scanner()) { // violation, name 'scanner' must
// match pattern '^[A-Z][A-Z0-9]*$'
final int VAR1 = 5; // OK
final int var1 = 10; // OK
} catch (final Exception ex) { // violation, name 'ex'
// must match pattern '^[A-Z][A-Z0-9]*$'
final int VAR2 = 15; // OK
final int var2 = 20; // OK
}
}
}
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 3.0
Checks that local, non-final variable names conform to a format specified by the format property. A catch parameter is considered to be a local variable.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[a-z][a-zA-Z0-9]*$" | 3.0 |
| allowOneCharVarInForLoop |
Allow one character variable name in
initialization expressions in FOR loop. For example:
for (int i = 1; i < 10; i++) {}
|
Boolean | false | 5.8 |
An example of how to configure the check is:
<module name="LocalVariableName"/>
Code Example:
class MyClass {
void MyMethod() {
for (int var = 1; var < 10; var++) {} // OK
for (int VAR = 1; VAR < 10; VAR++) {} // violation, name 'VAR' must match
// pattern '^[a-z][a-zA-Z0-9]*$'
for (int i = 1; i < 10; i++) {} // OK
for (int var_1 = 0; var_1 < 10; var_1++) {} // violation, name 'var_1' must match
// pattern '^[a-z][a-zA-Z0-9]*$'
}
}
An example of how to configure the check for names that begin with a lower case letter, followed by letters, digits, and underscores is:
<module name="LocalVariableName">
<property name="format" value="^[a-z](_?[a-zA-Z0-9]+)*$"/>
</module>
Code Example:
class MyClass {
void MyMethod() {
for (int var = 1; var < 10; var++) {} // OK
for (int VAR = 1; VAR < 10; VAR++) {} // violation, name 'VAR' must match
// pattern '^[a-z](_?[a-zA-Z0-9]+)*$'
for (int i = 1; i < 10; i++) {} // OK
for (int var_1 = 0; var_1 < 10; var_1++) {} // OK
}
}
An example of one character variable name in initialization expression(like "i") in FOR loop:
for(int i = 1; i < 10; i++) {}
An example of how to configure the check to allow one character variable name in initialization expressions in FOR loop:
<module name="LocalVariableName">
<property name="allowOneCharVarInForLoop" value="true"/>
</module>
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 3.0
Checks that instance variable names conform to a format specified by the format property.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[a-z][a-zA-Z0-9]*$" | 3.0 |
| applyToPublic | Controls whether to apply the check to public member. | Boolean | true | 3.4 |
| applyToProtected | Controls whether to apply the check to protected member. | Boolean | true | 3.4 |
| applyToPackage | Controls whether to apply the check to package-private member. | Boolean | true | 3.4 |
| applyToPrivate | Controls whether to apply the check to private member. | Boolean | true | 3.4 |
An example of how to configure the check is:
<module name="MemberName"/>
An example of how to configure the check for names that begin with "m", followed by an upper case letter, and then letters and digits is:
<module name="MemberName">
<property name="format" value="^m[A-Z][a-zA-Z0-9]*$"/>
</module>
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 3.0
Checks that method names conform to a format specified by the format property.
Also, checks if a method name has the same name as the residing class. The default is false (it is not allowed). It is legal in Java to have method with the same name as a class. As long as a return type is specified it is a method and not a constructor which it could be easily confused as. Does not check-style the name of an overridden methods because the developer does not have a choice in renaming such methods.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[a-z][a-zA-Z0-9]*$" | 3.0 |
| allowClassName |
Controls whether to allow a method name to have the same
name as the residing class name. This is not to be confused
with a constructor. An easy mistake is to place a return
type on a constructor declaration which turns it into a
method. For example:
class MyClass {
public void MyClass() {} //this is a method
public MyClass() {} //this is a constructor
}
|
Boolean | false | 5.0 |
| applyToPublic | Controls whether to apply the check to public member. | Boolean | true | 5.1 |
| applyToProtected | Controls whether to apply the check to protected member. | Boolean | true | 5.1 |
| applyToPackage | Controls whether to apply the check to package-private member. | Boolean | true | 5.1 |
| applyToPrivate | Controls whether to apply the check to private member. | Boolean | true | 5.1 |
An example of how to configure the check is:
<module name="MethodName"/>
An example of how to configure the check for names that begin with a lower case letter, followed by letters, digits, and underscores is:
<module name="MethodName">
<property name="format" value="^[a-z](_?[a-zA-Z0-9]+)*$"/>
</module>
Code Example:
class MyClass {
public void myMethod() {} // OK
public void MyMethod() {} // violation, name "MyMethod"
// should match the pattern "^[a-z](_?[a-zA-Z0-9]+)*$"
}
An example of how to configure the check to allow method names to be equal to the residing class name is:
<module name="MethodName">
<property name="format" value="^[a-zA-Z](_?[a-zA-Z0-9]+)*$"/>
<property name="allowClassName" value="true"/>
</module>
Code Example:
class MyClass {
public MyClass() {} // OK
public void MyClass() {} // OK, method Name 'MyClass' is allowed to be
// equal to the enclosing class name
}
An example of how to configure the check to disallow method names to be equal to the residing class name is:
<module name="MethodName">
<property name="format" value="^[a-zA-Z](_?[a-zA-Z0-9]+)*$"/>
<property name="allowClassName" value="false"/>
</module>
Code Example:
class MyClass {
public MyClass() {} // OK
public void MyClass() {} // violation, method Name 'MyClass' must not
// equal the enclosing class name
}
An example of how to suppress the check to public and protected methods:
<module name="MethodName">
<property name="format" value="^[a-z](_?[a-zA-Z0-9]+)*$"/>
<property name="applyToPublic" value="false">
<property name="applyToProtected" value="false">
</module>
Code Example:
class MyClass {
public void FirstMethod() {} // OK
protected void SecondMethod() {} // OK
private void ThirdMethod() {} // violation, name 'ThirdMethod' must match
// pattern '^[a-z](_?[a-zA-Z0-9]+)*$'
void FourthMethod() {} // violation, name 'FourthMethod' must match
// pattern '^[a-z](_?[a-zA-Z0-9]+)*$'
}
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 5.0
Checks that method type parameter names conform to a format specified by the format property.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[A-Z]$" | 5.0 |
An example of how to configure the check is:
<module name="MethodTypeParameterName"/>
An example of how to configure the check for names that are only a single letter is:
<module name="MethodTypeParameterName">
<property name="format" value="^[a-zA-Z]$"/>
</module>
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 3.0
Checks that package names conform to a format specified by the format property.
The default value of format for module PackageName 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 for module PackageName.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[a-z]+(\.[a-zA-Z_][a-zA-Z0-9_]*)*$" | 3.0 |
An example of how to configure the check is:
<module name="PackageName"/>
An example of how to configure the check to ensure with packages start with a lowercase letter and only contains lowercase letters or numbers is:
<module name="PackageName">
<property name="format"
value="^[a-z]+(\.[a-z][a-z0-9]*)*$"/>
</module>
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 3.0
Checks that method parameter names conform to a format specified by the format property. By using accessModifiers property it is possible to specify different formats for methods at different visibility levels.
To validate catch parameters please use CatchParameterName.
To validate lambda parameters please use LambdaParameterName.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[a-z][a-zA-Z0-9]*$" | 3.0 |
| ignoreOverridden |
Allows to skip methods with Override annotation from validation. For example, the
following method's parameter will be skipped from validation, if
ignoreOverridden is true:
@Override
public boolean equals(Object o) {
return super.equals(o);
}
|
Boolean | false | 6.12.1 |
| accessModifiers | Access modifiers of methods where parameters are checked. | Access Modifier Set | public, protected, package, private | 7.5 |
An example of how to configure the check:
<module name="ParameterName"/>
An example of how to configure the check for names that begin with a lower case letter, followed by letters, digits, and underscores:
<module name="ParameterName">
<property name="format" value="^[a-z][_a-zA-Z0-9]+$"/>
</module>
An example of how to configure the check to skip methods with Override annotation from validation:
<module name="ParameterName">
<property name="ignoreOverridden" value="true"/>
</module>
An example of how to configure the check for names that begin with a lower case letter, followed by letters and digits is:
<module name="ParameterName">
<property name="format" value="^[a-z][a-zA-Z0-9]+$"/>
</module>
The following configuration checks that the parameters always start with two lowercase characters and, in addition, that public method parameters cannot be one character long:
<module name="ParameterName">
<property name="format" value="^[a-z]([a-z0-9][a-zA-Z0-9]*)?$"/>
<property name="accessModifiers" value="protected, package, private"/>
<message key="name.invalidPattern"
value="Parameter name ''{0}'' must match pattern ''{1}''"/>
</module>
<module name="ParameterName">
<property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9]*$"/>
<property name="accessModifiers" value="public"/>
<message key="name.invalidPattern"
value="Parameter name ''{0}'' must match pattern ''{1}''"/>
</module>
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 3.0
Checks that {@code static}, non-{@code final} variable names conform to a format specified by the format property.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[a-z][a-zA-Z0-9]*$" | 3.0 |
| applyToPublic | Controls whether to apply the check to public member. | Boolean | true | 5.0 |
| applyToProtected | Controls whether to apply the check to protected member. | Boolean | true | 5.0 |
| applyToPackage | Controls whether to apply the check to package-private member. | Boolean | true | 5.0 |
| applyToPrivate | Controls whether to apply the check to private member. | Boolean | true | 5.0 |
An example of how to configure the check is:
<module name="StaticVariableName"/>
An example of how to configure the check for names that begin with a lower case letter, followed by letters, digits, and underscores is:
<module name="StaticVariableName">
<property name="format" value="^[a-z](_?[a-zA-Z0-9]+)*$"/>
</module>
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.
Since Checkstyle 3.0
Checks that type names for classes, interfaces, enums, and annotations conform to a format specified by the format property.
| name | description | type | default value | since |
|---|---|---|---|---|
| format | Specifies valid identifiers. | Regular Expression | "^[A-Z][a-zA-Z0-9]*$" | 3.0 |
| applyToPublic | Controls whether to apply the check to public member. | Boolean | true | 5.0 |
| applyToProtected | Controls whether to apply the check to protected member. | Boolean | true | 5.0 |
| applyToPackage | Controls whether to apply the check to package-private member. | Boolean | true | 5.0 |
| applyToPrivate | Controls whether to apply the check to private member. | Boolean | true | 5.0 |
| tokens | tokens to check | subset of tokens CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF. | CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF. | 3.0 |
An example of how to configure the check is:
<module name="TypeName"/>
An example of how to configure the check for names that begin with a lower case letter, followed by letters, digits, and underscores is:
<module name="TypeName">
<property name="format" value="^[a-z](_?[a-zA-Z0-9]+)*$"/>
</module>
The following configuration element ensures that interface names begin with "I_", followed by letters and digits:
<module name="TypeName">
<property name="format"
value="^I_[a-zA-Z0-9]*$"/>
<property name="tokens"
value="INTERFACE_DEF"/>
</module>
All messages can be customized if the default message doesn't suit you. Please see the documentation to learn how to.