All Classes

Class	Description
AbbreviationAsWordInNameCheck	Validates abbreviations (consecutive capital letters) length in identifier name, it also allows to enforce camel case naming.
AbstractAccessControlNameCheck	Abstract class for checking a class member (field/method)'s name conforms to a specified pattern.
AbstractAutomaticBean	A Java Bean that implements the component lifecycle interfaces by calling the bean's setters for all configuration attributes.
AbstractAutomaticBean.OutputStreamOptions	Enum to specify behaviour regarding ignored modules.
AbstractAutomaticBean.PatternArrayConverter	A converter that converts a comma-separated string into an array of patterns.
AbstractAutomaticBean.PatternConverter	A converter that converts a string to a pattern.
AbstractAutomaticBean.RelaxedAccessModifierArrayConverter	A converter that converts strings to AccessModifierOption.
AbstractAutomaticBean.RelaxedStringArrayConverter	A converter that does not care whether the array elements contain String characters like '*' or '_'.
AbstractAutomaticBean.ScopeConverter	A converter that converts strings to scope.
AbstractAutomaticBean.SeverityLevelConverter	A converter that converts strings to severity level.
AbstractAutomaticBean.UriConverter	A converter that converts strings to uri.
AbstractCheck	The base class for checks.
AbstractCheck.FileContext	The actual context holder.
AbstractClassCouplingCheck	Base class for coupling calculation.
AbstractClassNameCheck	Ensures that the names of abstract classes conforming to some pattern and check that abstract modifier exists.
AbstractElementNode	Represents element node of Xpath-tree.
AbstractExpressionHandler	Abstract base class for all handlers.
AbstractFileSetCheck	Provides common functionality for many FileSetChecks.
AbstractFileSetCheck.FileContext	The actual context holder.
AbstractHeaderCheck	Abstract super class for header checks.
AbstractImportControl	Represents a tree of import rules for controlling whether packages or classes are allowed to be used.
AbstractImportRule	Base class for import rules.
AbstractJavadocCheck	Base class for Checks that process Javadoc comments.
AbstractJavadocCheck.FileContext	The file context holder.
AbstractNameCheck	Abstract class for checking that names conform to a specified format.
AbstractNode	Represents general class for ElementNode, RootNode and AttributeNode.
AbstractParenPadCheck	Abstract class for checking the padding of parentheses.
AbstractRootNode	Represents root node of Xpath-tree.
AbstractSuperCheck	Abstract class for checking that an overriding method with no parameters invokes the super method.
AbstractSuperCheck.MethodNode	Stack node for a method definition and a record of whether the method has a call to the super method.
AbstractViolationReporter	Serves as an abstract base class for all modules that report inspection findings.
AccessModifierOption	This enum represents access modifiers.
AccessResult	Represents the result of an access check.
AnnotationArrayInitHandler	Handler for annotation array initialization blocks.
AnnotationLocationCheck	Checks location of annotation on language elements.
AnnotationOnSameLineCheck	Checks that annotations are located on the same line with their targets.
AnnotationUseStyleCheck	Checks the style of elements in annotations.
AnnotationUseStyleCheck.ClosingParensOption	Defines the two styles for defining elements in an annotation.
AnnotationUseStyleCheck.ElementStyleOption	Defines the styles for defining elements in an annotation.
AnnotationUseStyleCheck.TrailingArrayCommaOption	Defines the two styles for defining elements in an annotation.
AnnotationUtil	Contains utility methods designed to work with annotations.
AnonInnerLengthCheck	Checks for long anonymous inner classes.
ArrayInitHandler	Handler for array initialization blocks.
ArrayTrailingCommaCheck	Checks that array initialization contains a trailing comma.
ArrayTypeStyleCheck	Checks the style of array type definitions.
AstTreeStringPrinter	Class for printing AST to String.
AtclauseOrderCheck	Checks the order of javadoc block-tags or javadoc tags.
AttributeNode	Represents attribute of the element.
AuditEvent	Raw event for audit.
AuditEventDefaultFormatter	Represents the default formatter for log message.
AuditEventFormatter	Represents the formatter interface for log message.
AuditListener	Listener in charge of receiving events from the Checker.
AutomaticBean	Deprecated. since 10.9.3.
AutomaticBean.OutputStreamOptions	Enum to specify behaviour regarding ignored modules.
AvoidDoubleBraceInitializationCheck	Detects double brace initialization.
AvoidEscapedUnicodeCharactersCheck	Restricts using Unicode escapes (such as \u221e).
AvoidInlineConditionalsCheck	Detects inline conditionals.
AvoidNestedBlocksCheck	Finds nested blocks (blocks that are used freely in the code).
AvoidNoArgumentSuperConstructorCallCheck	Checks if call to superclass constructor without arguments is present.
AvoidStarImportCheck	Checks that there are no import statements that use the * notation.
AvoidStaticImportCheck	Checks that there are no static import statements.
BaseCellEditor	A base class for CellEditors, providing default implementations for all methods in the CellEditor interface and support for managing a series of listeners.
BeforeExecutionExclusionFileFilter	File filter BeforeExecutionExclusionFileFilter decides which files should be excluded from being processed by the utility.
BeforeExecutionFileFilter	An interface for before execution file filtering events.
BeforeExecutionFileFilterSet	A before execution file filter set applies filters to events.
BlockCommentPosition	Utility class that has methods to check javadoc comment position in java file.
BlockOption	Represents the policy for checking block statements.
BlockParentHandler	Handler for parents of blocks ('if', 'else', 'while', etc).
BlockTagUtil	Tools for parsing block tags from a Javadoc comment.
BooleanExpressionComplexityCheck	Restricts the number of boolean operators (&&, ||, &, | and ^) in an expression.
CaseHandler	Handler for case statements.
CatchHandler	Handler for catch blocks.
CatchParameterNameCheck	Checks that catch parameter names conform to a specified pattern.
ChainedPropertyUtil	Resolves chained properties from a user-defined property file.
Checker	This class provides the functionality to check a set of files.
CheckstyleAntTask	An implementation of an ANT task for calling checkstyle.
CheckstyleAntTask.Formatter	Details about a formatter to be used.
CheckstyleAntTask.FormatterType	Poor man enumeration for the formatter types.
CheckstyleAntTask.Property	Represents a property that consists of a key and value.
CheckstyleException	Represents an error condition within Checkstyle.
CheckstyleParserErrorStrategy	Extending BailErrorStrategy allows us to report errors while cancelling the parsing operation.
CheckUtil	Contains utility methods for the checks.
ClassAndPropertiesSettersJavadocScraper	Class for scraping class javadoc and all property setter javadocs from the given checkstyle module.
ClassDataAbstractionCouplingCheck	Measures the number of distinct classes that are instantiated within the given class or record.
ClassDefHandler	Handler for class definitions.
ClassFanOutComplexityCheck	Checks the number of other types a given class/record/interface/enum/annotation relies on.
ClassImportRule	Represents whether a class is allowed to be imported or not.
ClassMemberImpliedModifierCheck	Checks for implicit modifiers on nested types in classes and records.
ClassTypeParameterNameCheck	Checks that class type parameter names conform to a specified pattern.
CodePointUtil	Contains utility methods for code point.
CodeSelector	Helper class to select a code.
CodeSelectorPresentation	Presentation model for CodeSelector.
Comment	Representation of the comment block.
CommentListener	This interface is used to be notified by parser about comments in the parsed code.
CommentsIndentationCheck	Controls the indentation between comments and surrounding code.
CommentSuppressor	Implementation of a MatchSuppressor that suppresses based on whether in a comment.
CommonUtil	Contains utility methods.
Configurable	A component that can be configured.
Configuration	A Configuration is used to configure a Configurable component.
ConfigurationLoader	Loads a configuration from a standard configuration XML file.
ConfigurationLoader.IgnoredModulesOptions	Enum to specify behaviour regarding ignored modules.
ConstantNameCheck	Checks that constant names conform to a specified pattern.
ConstructorsDeclarationGroupingCheck	Checks that all constructors are grouped together.
Context	A context to be used in subcomponents.
Contextualizable	A Component that needs context information from its container(parent object) to work.
CovariantEqualsCheck	Checks that classes and records which define a covariant equals() method also override method equals(Object).
CrAwareLexerSimulator	Extends the LexerATNSimulator class in order to override the 'consume()' method so that we can handle '\r' line endings (pre-OSX macOS line endings) correctly in the ANTLR lexer.
CsvFilterElement	This filter element is immutable and accepts an integer that matches a CSV value, where each value is an integer or a range of integers.
CustomImportOrderCheck	Checks that the groups of import declarations appear in the order specified by the user.
CustomImportOrderCheck.ImportDetails	Contains import attributes as line number, import full path, import group.
CustomImportOrderCheck.RuleMatchForImport	Contains matching attributes assisting in definition of "best matching" group for import.
CyclomaticComplexityCheck	Checks cyclomatic complexity against a specified limit.
DeclarationOrderCheck	Checks that the parts of a class, record, or interface declaration appear in the order suggested by the Code Conventions for the Java Programming Language.
DeclarationOrderCheck.ScopeState	Private class to encapsulate the state.
DefaultComesLastCheck	Check that the default is after all the cases in a switch statement.
DefaultConfiguration	Default implementation of the Configuration interface.
DefaultContext	A default implementation of the Context interface.
DefaultLogger	Simple plain logger for text output.
Definitions	Contains constant definitions common to the package.
DescendantIterator	Recursive-free implementation of the descendant axis iterator.
DescendantIterator.StartWith	Enum defines starting node for iterator.
DescendantTokenCheck	Checks for restricted tokens beneath other tokens.
DesignForExtensionCheck	Checks that classes are designed for extension (subclass creation).
DetailAST	An interface of Checkstyle's AST nodes for traversing trees generated from the Java code.
DetailAstImpl	The implementation of DetailAST.
DetailAstSet	Represents a set of abstract syntax tree.
DetailNode	DetailNode is used to construct tree during parsing Javadoc comments.
DetailNodeTreeStringPrinter	Parses file as javadoc DetailNode tree and prints to system output stream.
DetectorOptions	Options for a detector.
DoWhileHandler	Handler for do...while blocks.
ElementNode	Represents DetailAST's element node of Xpath-tree.
ElseHandler	Handler for else blocks.
EmptyBlockCheck	Checks for empty blocks.
EmptyCatchBlockCheck	Checks for empty catch blocks.
EmptyForInitializerPadCheck	Checks the padding of an empty for initializer; that is whether a white space is required at an empty for initializer, or such white space is forbidden.
EmptyForIteratorPadCheck	Checks the padding of an empty for iterator; that is whether a white space is required at an empty for iterator, or such white space is forbidden.
EmptyLineSeparatorCheck	Checks for empty line separators before package, all import declarations, fields, constructors, methods, nested classes, static initializers and instance initializers.
EmptyStatementCheck	Detects empty statements (standalone ";" semicolon).
EqualsAvoidNullCheck	Checks that any combination of String literals is on the left side of an equals() comparison.
EqualsAvoidNullCheck.FieldFrame	Holds the names of fields of a type.
EqualsHashCodeCheck	Checks that classes that either override equals() or hashCode() also overrides the other.
ExampleMacro	A macro that inserts a snippet of code or configuration from a file.
ExecutableStatementCountCheck	Restricts the number of executable statements to a specified limit.
ExecutableStatementCountCheck.Context	Class to encapsulate counting information about one member.
ExplicitInitializationCheck	Checks if any class or object member is explicitly initialized to default for its type value (null for object references, zero for numeric types and char and false for boolean.
ExternalResourceHolder	The following interface should be implemented by each module (inheritor of AbstractCheck, implementor of FileSetCheck, or Filter) which uses external resources of any kind for its configuration.
FallThroughCheck	Checks for fall-through in switch statements.
FileContents	Represents the contents of a file.
FileImportControl	Represents an import rules for a specific file.
FileLengthCheck	Checks for long source files.
FileSetCheck	Interface for Checking a set of files for some criteria.
FileStatefulCheck	This annotation means that the check contains file-related context and therefore cannot be used from the others threads at the same time.
FileTabCharacterCheck	Checks that there are no tab characters ('\t') in the source code.
FileText	Represents the text contents of a file of arbitrary plain text type.
Filter	An interface for filtering AuditEvents.
FilterSet	A filter set applies filters to AuditEvents.
FilterUtil	Utility methods for suppression filters.
FinalClassCheck	Ensures that identifies classes that can be effectively declared as final are explicitly marked as final.
FinalClassCheck.ClassDesc	Maintains information about the class.
FinalClassCheck.TypeDeclarationDescription	Maintains information about the type of declaration.
FinalLocalVariableCheck	Checks that local variables that never have their values changed are declared final.
FinalLocalVariableCheck.FinalVariableCandidate	Represents information about final local variable candidate.
FinalLocalVariableCheck.ScopeData	Holder for the scope data.
FinallyHandler	Handler for finally blocks.
FinalParametersCheck	Checks that parameters for methods, constructors, catch and for-each blocks are final.
FollowingIterator	Recursive-free implementation of the following axis iterator.
ForHandler	Handler for for loops.
FullIdent	Represents a full identifier, including dots, with associated position information.
GenericWhitespaceCheck	Checks that the whitespace around the Generic tokens (angle brackets) "<" and ">" are correct to the typical convention.
GlobalStatefulCheck	This annotation means that the check contains global context, which will be updated while Checkstyle processes files.
HandlerFactory	Factory for handlers.
HeaderCheck	Checks that a source file begins with a specified header.
HiddenFieldCheck	Checks that a local variable or a parameter does not shadow a field that is defined in the same class.
HiddenFieldCheck.FieldFrame	Holds the names of static and instance fields of a type.
HideUtilityClassConstructorCheck	Makes sure that utility classes (classes that contain only static methods or fields in their API) do not have a public constructor.
HideUtilityClassConstructorCheck.Details	Details of class that are required for validation.
HtmlTag	Used to keep track of a tag and the text that follows it.
IfHandler	Handler for if statements.
IllegalCatchCheck	Checks that certain exception types do not appear in a catch statement.
IllegalIdentifierNameCheck	Checks identifiers with a pattern for a set of illegal names, such as those that are restricted or contextual keywords.
IllegalImportCheck	Checks for imports from a set of illegal packages.
IllegalInstantiationCheck	Checks for illegal instantiations where a factory method is preferred.
IllegalThrowsCheck	Checks that specified types are not declared to be thrown.
IllegalTokenCheck	Checks for illegal tokens.
IllegalTokenTextCheck	Checks specified tokens text for matching an illegal pattern.
IllegalTypeCheck	Checks that particular classes or interfaces are never used.
ImportControlCheck	Controls what can be imported in each package and file.
ImportControlLoader	Responsible for loading the contents of an import control configuration file.
ImportHandler	Handler for import statements.
ImportOrderCheck	Checks the ordering/grouping of imports.
ImportOrderOption	Represents the policy for checking import order statements.
IndentationCheck	Checks correct indentation of Java code.
IndentLevel	Encapsulates representation of notion of expected indentation levels.
IndexHandler	Handler for array index operation.
InlineTagUtil	Tools for extracting inline tags from Javadoc comments.
InnerAssignmentCheck	Checks for assignments in subexpressions, such as in String s = Integer.toString(i = 2);.
InnerTypeLastCheck	Checks nested (internal) classes/interfaces are declared at the bottom of the primary (top-level) class after all init and static init blocks, method, constructor and field declarations.
InterfaceIsTypeCheck	Implements Joshua Bloch, Effective Java, Item 17 - Use Interfaces only to define types.
InterfaceMemberImpliedModifierCheck	Checks for implicit modifiers on interface members and nested types.
InterfaceTypeParameterNameCheck	Checks that interface type parameter names conform to a specified pattern.
IntFilterElement	An interface for filtering Integer.
IntMatchFilterElement	This filter element is immutable and accepts a matching Integer.
IntRangeFilterElement	This filter element is immutable and accepts an Integer in a range.
InvalidJavadocPositionCheck	Checks that Javadocs are located at the correct position.
InvalidJavadocTag	Value object for storing data about an invalid Javadoc validTags.
JavaAstVisitor	Visitor class used to build Checkstyle's Java AST from the parse tree produced by JavaLanguageParser.
JavaAstVisitor.DetailAstPair	Used to swap and organize DetailAstImpl subtrees.
JavadocBlockTagLocationCheck	Checks that a javadoc block tag appears only at the beginning of a line, ignoring leading asterisks and white space.
JavadocContentLocationCheck	Checks that the Javadoc content begins from the same position for all Javadoc comments in the project.
JavadocContentLocationOption	Represents the locations for the javadoc content.
JavadocDetailNodeParser	Used for parsing Javadoc comment as DetailNode tree.
JavadocDetailNodeParser.DescriptiveErrorListener	Custom error listener for JavadocParser that prints user readable errors.
JavadocDetailNodeParser.ParseErrorMessage	Contains information about parse error message.
JavadocDetailNodeParser.ParseStatus	Contains result of parsing javadoc comment: DetailNode tree and parse error message.
JavadocLeadingAsteriskAlignCheck	Checks the alignment of leading asterisks in a Javadoc comment.
JavadocMetadataScraper	Class for scraping module metadata from the corresponding class' class-level javadoc.
JavadocMethodCheck	Checks the Javadoc of a method or constructor.
JavadocMethodCheck.ClassInfo	Contains class's Token.
JavadocMethodCheck.ExceptionInfo	Stores useful information about declared exception.
JavadocMethodCheck.Token	Represents text element with location in the text.
JavadocMissingLeadingAsteriskCheck	Checks if the javadoc has leading asterisks on each line.
JavadocMissingWhitespaceAfterAsteriskCheck	Checks that there is at least one whitespace after the leading asterisk.
JavadocNodeImpl	Implementation of DetailNode interface that is mutable.
JavadocPackageCheck	Checks that each Java package has a Javadoc file used for commenting.
JavadocParagraphCheck	Checks the Javadoc paragraph.
JavadocPropertiesGenerator	This class is used internally in the build process to write a property file with short descriptions (the first sentences) of TokenTypes constants.
JavadocPropertiesGenerator.CliOptions	Helper class encapsulating the command line options and positional parameters.
JavadocStyleCheck	Validates Javadoc comments to help ensure they are well formed.
JavadocTag	Represents a Javadoc tag.
JavadocTagContinuationIndentationCheck	Checks the indentation of the continuation lines in block tags.
JavadocTagInfo	This enum defines the various Javadoc tags and their properties.
JavadocTagInfo.Type	The Javadoc Type.
JavadocTags	Value object for combining the list of valid validTags with information about invalid validTags encountered in a certain Javadoc comment.
JavadocTokenTypes	Contains the constants for all the tokens contained in the Abstract Syntax Tree for the javadoc grammar.
JavadocTypeCheck	Checks the Javadoc comments for type definitions.
JavadocUtil	Contains utility methods for working with Javadoc.
JavadocUtil.JavadocTagType	The type of Javadoc tag we want returned.
JavadocVariableCheck	Checks that a variable has a Javadoc comment.
JavaNCSSCheck	Determines complexity of methods, classes and files by counting the Non Commenting Source Statements (NCSS).
JavaNCSSCheck.Counter	Class representing a counter.
JavaParser	Helper methods to parse java source files.
JavaParser.CheckstyleErrorListener	Custom error listener to provide detailed exception message.
JavaParser.Options	Enum to be used for test if comments should be used.
LabelHandler	Handler for labels.
LambdaBodyLengthCheck	Checks lambda body length.
LambdaHandler	Handler for lambda expressions.
LambdaParameterNameCheck	Checks lambda parameter names.
LeftCurlyCheck	Checks for the placement of left curly braces ('{') for code blocks.
LeftCurlyOption	Represents the options for placing the left curly brace '{'.
LineColumn	Immutable line and column numbers.
LineLengthCheck	Checks for long lines.
LineSeparatorOption	Represents the options for line separator settings.
LineWrappingHandler	This class checks line-wrapping into definitions and expressions.
LineWrappingHandler.LineWrappingOptions	Enum to be used for test if first line's indentation should be checked or not.
ListToTreeSelectionModelWrapper	ListToTreeSelectionModelWrapper extends DefaultTreeSelectionModel to listen for changes in the ListSelectionModel it maintains.
LocalFinalVariableNameCheck	Checks that local final variable names conform to a specified pattern.
LocalizedMessage	Represents a message that can be localised.
LocalizedMessage.Utf8Control	Custom ResourceBundle.Control implementation which allows explicitly read the properties files as UTF-8.
LocalVariableNameCheck	Checks that local, non-final variable names conform to a specified pattern.
MagicNumberCheck	Checks that there are no "magic numbers" where a magic number is a numeric literal that is not defined as a constant.
Main	Entry point for starting the checkstyle GUI.
Main	Wrapper command line program for the Checker.
Main.CliOptions	Command line options.
Main.OnlyCheckstyleLoggersFilter	Log Filter used in debug mode.
Main.OutputFormat	Enumeration over the possible output formats.
MainFrame	Displays information about a parse tree.
MainFrame.JavaFileFilter	Filter for Java files.
MainFrameModel	Model for checkstyle frame.
MainFrameModel.ParseMode	Parsing modes which available in GUI.
MatchSuppressor	Represents a suppressor for matches.
MatchXpathCheck	Evaluates Xpath query and report violation on all matching AST nodes.
MemberDefHandler	Handler for member definitions.
MemberNameCheck	Checks that instance variable names conform to a specified pattern.
MessageDispatcher	Used by FileSetChecks to distribute AuditEvents to AuditListeners.
MetadataGenerationException	Exception for metadata generation errors.
MetadataGeneratorLogger	Simple logger for metadata generator util.
MetadataGeneratorUtil	Class which handles all the metadata generation and writing calls.
MethodCallHandler	Handler for method calls.
MethodCountCheck	Checks the number of methods declared in each type declaration by access modifier or total count.
MethodCountCheck.MethodCounter	Marker class used to collect data about the number of methods per class.
MethodDefHandler	Handler for method definitions.
MethodLengthCheck	Checks for long methods and constructors.
MethodNameCheck	Checks that method names conform to a specified pattern.
MethodParamPadCheck	Checks the padding between the identifier of a method definition, constructor definition, method call, constructor invocation, record, or record pattern; and the left parenthesis of the parameter list.
MethodTypeParameterNameCheck	Checks that method type parameter names conform to a specified pattern.
MismatchStrategy	Represents the strategy when none of the rules (allow/disallow tags) match inside subpackage and import-control tag of ImportControlCheck config.
MissingCtorCheck	Checks that classes (except abstract ones) define a constructor and don't rely on the default one.
MissingDeprecatedCheck	Verifies that the annotation @Deprecated and the Javadoc tag @deprecated are both present when either of them is present.
MissingJavadocMethodCheck	Checks for missing Javadoc comments for a method or constructor.
MissingJavadocPackageCheck	Checks for missing package definition Javadoc comments in package-info.java files.
MissingJavadocTypeCheck	Checks for missing Javadoc comments for class, enum, interface, and annotation interface definitions.
MissingNullCaseInSwitchCheck	Checks that a given switch statement or expression that use a reference type in its selector expression has a null case label.
MissingOverrideCheck	Verifies that the @Override annotation is present when the @inheritDoc javadoc tag is present.
MissingSwitchDefaultCheck	Checks that switch statement has a default clause.
ModifiedControlVariableCheck	Checks that for loop control variables are not modified inside the for block.
ModifierOrderCheck	Checks that the order of modifiers conforms to the suggestions in the Java Language specification, § 8.1.1, 8.3.1, 8.4.3 and 9.4.
ModuleDetails	Simple POJO class for module details.
ModuleFactory	A module factory creates Objects from a given name.
ModulePropertyDetails	Simple POJO class module's property details.
ModuleReflectionUtil	Contains utility methods for module reflection.
ModuleType	Enum holding the types of module which can exist.
MultilineDetector	A detector that matches across multiple lines.
MultipleStringLiteralsCheck	Checks for multiple occurrences of the same string literal within a single file.
MultipleVariableDeclarationsCheck	Checks that each variable declaration is in its own statement and on its own line.
MutableExceptionCheck	Ensures that exception classes (classes with names conforming to some pattern and explicitly extending classes with names conforming to other pattern) are immutable, that is, that they have only final fields.
NeedBracesCheck	Checks for braces around code blocks.
NestedForDepthCheck	Restricts nested for blocks to a specified depth.
NestedIfDepthCheck	Restricts nested if-else blocks to a specified depth.
NestedTryDepthCheck	Restricts nested try-catch-finally blocks to a specified depth.
NeverSuppress	An implementation of MatchSuppressor that never suppresses a match.
NewHandler	Handler for operator new.
NewlineAtEndOfFileCheck	Checks whether files end with a line separator.
NoArrayTrailingCommaCheck	Checks that array initialization do not contain a trailing comma.
NoCloneCheck	Checks that the clone method is not overridden from the Object class.
NoCodeInFileCheck	Checks whether file contains code.
NoEnumTrailingCommaCheck	Checks that enum definition does not contain a trailing comma.
NoFinalizerCheck	Checks that there is no method finalize with zero parameters.
NoLineWrapCheck	Checks that chosen statements are not line-wrapped.
NonEmptyAtclauseDescriptionCheck	Checks that the block tag is followed by description.
NoWhitespaceAfterCheck	Checks that there is no whitespace after a token.
NoWhitespaceBeforeCaseDefaultColonCheck	Checks that there is no whitespace before the colon in a switch block.
NoWhitespaceBeforeCheck	Checks that there is no whitespace before a token.
NPathComplexityCheck	Checks the NPATH complexity against a specified limit.
NPathComplexityCheck.TokenEnd	Coordinates of token end.
NPathComplexityCheck.Values	Class that store range value and expression value.
ObjectBlockHandler	Handler for inner classes.
OneStatementPerLineCheck	Checks that there is only one statement per line.
OneTopLevelClassCheck	Checks that each top-level class, interface, enum or annotation resides in a source file of its own.
OperatorWrapCheck	Checks the policy on how to wrap lines on operators.
OrderedPropertiesCheck	Detects if keys in properties files are in correct order.
OrderedPropertiesCheck.SequencedProperties	Private property implementation that keeps order of properties like in file.
OsSpecificUtil	Class which provides OS related utilities.
OuterTypeFilenameCheck	Checks that the outer type name and the file name match.
OuterTypeNumberCheck	Checks for the number of types declared at the outer (or root) level in a file.
OverloadMethodsDeclarationOrderCheck	Checks that overloaded methods are grouped together.
PackageAnnotationCheck	Checks that all package annotations are in the package-info.java file.
PackageDeclarationCheck	Ensures that a class has a package declaration, and (optionally) whether the package name matches the directory name for the source file.
PackageDefHandler	Handler for package definitions.
PackageNameCheck	Checks that package names conform to a specified pattern.
PackageNamesLoader	Loads a list of package names from a package name XML file.
PackageObjectFactory	A factory for creating objects from package names and names.
PackageObjectFactory.ModuleLoadOption	Enum class to define loading options.
PadOption	Represents the options for whitespace around parentheses.
ParameterAssignmentCheck	Disallows assignment of parameters.
ParameterNameCheck	Checks that method parameter names conform to a specified pattern.
ParameterNumberCheck	Checks the number of parameters of a method or constructor.
ParenPadCheck	Checks the policy on the padding of parentheses; that is whether a space is required after a left parenthesis and before a right parenthesis, or such spaces are forbidden.
ParentModuleMacro	A macro that inserts a link to the parent module.
ParserUtil	Contains utility methods for parser to use while creating ast.
ParseTreeTableModel	The model that backs the parse tree in the GUI.
ParseTreeTablePresentation	The model that backs the parse tree in the GUI.
PatternVariableNameCheck	Checks that pattern variable names conform to a specified pattern.
PkgImportControl	Represents a tree of import rules for a specific package.
PkgImportRule	Represents whether a package is allowed to be imported or not.
PrecedingIterator	Recursive-free implementation of the preceding axis iterator.
PrimordialHandler	A default no-op handler.
PropertiesExpander	Resolves external properties from an underlying Properties object.
PropertiesMacro	A macro that inserts a table of properties for the given checkstyle module.
PropertyCacheFile	This class maintains a persistent(on file-system) store of the files that have checked ok(no validation events) and their associated timestamp.
PropertyCacheFile.ExternalResource	Class which represents external resource.
PropertyResolver	Resolves properties in module configurations.
PropertyType	Represents the custom property type used in documentation and configuration files.
RecordComponentNameCheck	Checks that record component names conform to a specified pattern.
RecordComponentNumberCheck	Checks the number of record components in the header of a record definition.
RecordTypeParameterNameCheck	Checks that record type parameter names conform to a specified pattern.
RedundantImportCheck	Checks for redundant import statements.
RedundantModifierCheck	Checks for redundant modifiers.
RegexpCheck	Checks that a specified pattern exists, exists less than a set number of times, or does not exist in the file.
RegexpHeaderCheck	Checks the header of a source file against a header that contains a pattern for each line of the source header.
RegexpMultilineCheck	Checks that a specified pattern matches across multiple lines in any file type.
RegexpOnFilenameCheck	Checks that a specified pattern matches based on file and/or folder path.
RegexpSinglelineCheck	Checks that a specified pattern matches a single-line in any file type.
RegexpSinglelineJavaCheck	Checks that a specified pattern matches a single-line in Java files.
RequireEmptyLineBeforeBlockTagGroupCheck	Checks that one blank line before the block tag if it is present in Javadoc.
RequireThisCheck	Checks that references to instance variables and methods of the present object are explicitly of the form "this.varName" or "this.methodName(args)" and that those references don't rely on the default behavior when "this." is absent.
RequireThisCheck.AbstractFrame	A declaration frame.
RequireThisCheck.AnonymousClassFrame	An anonymous class frame; holds instance variable names.
RequireThisCheck.BlockFrame	A frame initiated on entering a statement list; holds local variable names.
RequireThisCheck.CatchFrame	A frame initiated on entering a catch block; holds local catch variable names.
RequireThisCheck.ClassFrame	A frame initiated at class, enum or interface definition; holds instance variable names.
RequireThisCheck.ConstructorFrame	A frame initiated at constructor definition.
RequireThisCheck.ForFrame	A frame initiated on entering a for block; holds local for variable names.
RequireThisCheck.FrameType	An AbstractFrame type.
RequireThisCheck.MethodFrame	A frame initiated at method definition; holds a method definition token.
RequireThisCheck.TryWithResourcesFrame	A frame initiated on entering a try-with-resources construct; holds local resources for the try block.
ReturnCountCheck	Restricts the number of return statements in methods, constructors and lambda expressions.
ReverseDescendantIterator	Recursive-free implementation of the descendant axis iterator.
ReverseListIterator	Iterates list in backward direction.
RightCurlyCheck	Checks the placement of right curly braces ('}') for code blocks.
RightCurlyCheck.Details	Structure that contains all details for validation.
RightCurlyOption	Represents the options for placing the right curly brace '}'.
RootModule	The first module that is run as part of Checkstyle and controls its entire behavior and children.
RootNode	Represents DetailAST's root node of Xpath-tree.
SarifLogger	Simple SARIF logger.
Scope	Represents a Java visibility scope.
ScopeUtil	Contains utility methods for working on scope.
SealedShouldHavePermitsListCheck	Checks that sealed classes and interfaces have a permits list.
SeparatorWrapCheck	Checks line wrapping with separators.
SeverityLevel	Severity level for a check violation.
SeverityLevelCounter	An audit listener that counts how many AuditEvents of a given severity have been generated.
SeverityMatchFilter	Filter SeverityMatchFilter decides audit events according to the severity level of the event.
SimplifyBooleanExpressionCheck	Checks for over-complicated boolean expressions.
SimplifyBooleanReturnCheck	Checks for over-complicated boolean return or yield statements.
SinglelineDetector	A detector that matches individual lines.
SingleLineJavadocCheck	Checks that a Javadoc block can fit in a single-line and doesn't contain block tags.
SingleSpaceSeparatorCheck	Checks that non-whitespace characters are separated by no more than one whitespace.
SiteUtil	Utility class for site generation.
SiteUtil.DescriptionExtractor	Utility class for extracting description from a method's Javadoc.
SlistHandler	Handler for a list of statements.
StatelessCheck	This annotation means that the check does not contain mutable state and may be safely used from others threads at the same time.
StaticInitHandler	Handler for static initialization blocks.
StaticVariableNameCheck	Checks that static, non-final variable names conform to a specified pattern.
StringLiteralEqualityCheck	Checks that string literals are not used with == or !=.
SummaryJavadocCheck	Checks that Javadoc summary sentence does not contain phrases that are not recommended to use.
SuperCloneCheck	Checks that an overriding clone() method invokes super.clone().
SuperFinalizeCheck	Checks that an overriding finalize() method invokes super.finalize().
SuppressFilterElement	This filter element is immutable and processes AuditEvent objects based on the criteria of file, check, module id, line, and column.
SuppressionCommentFilter	Filter SuppressionCommentFilter uses pairs of comments to suppress audit events.
SuppressionCommentFilter.Tag	A Tag holds a suppression comment and its location, and determines whether the suppression turns checkstyle reporting on or off.
SuppressionCommentFilter.TagType	Enum to be used for switching checkstyle reporting for tags.
SuppressionFilter	Filter SuppressionFilter rejects audit events for Check violations according to a suppressions XML document in a file.
SuppressionSingleFilter	Filter SuppressionSingleFilter suppresses audit events for Checks violations in the specified file, class, checks, message, module id, lines, and columns.
SuppressionsLoader	Loads a filter chain of suppressions.
SuppressionsStringPrinter	Class for constructing xpath queries to suppress nodes with specified line and column number.
SuppressionXpathFilter	Filter SuppressionXpathFilter works as SuppressionFilter.
SuppressionXpathSingleFilter	Filter SuppressionXpathSingleFilter suppresses audit events for Checks violations in the specified file, class, checks, message, module id, and xpath.
SuppressWarningsCheck	Allows to specify what warnings that @SuppressWarnings is not allowed to suppress.
SuppressWarningsFilter	Filter SuppressWarningsFilter uses annotation @SuppressWarnings to suppress audit events.
SuppressWarningsHolder	Maintains a set of check suppressions from @SuppressWarnings annotations.
SuppressWarningsHolder.Entry	Records a particular suppression for a region of a file.
SuppressWithNearbyCommentFilter	Filter SuppressWithNearbyCommentFilter uses nearby comments to suppress audit events.
SuppressWithNearbyCommentFilter.Tag	A Tag holds a suppression comment and its location.
SuppressWithNearbyTextFilter	Filter SuppressWithNearbyTextFilter uses plain text to suppress nearby audit events.
SuppressWithNearbyTextFilter.Suppression	The class which represents the suppression.
SuppressWithPlainTextCommentFilter	Filter SuppressWithPlainTextCommentFilter uses plain text to suppress audit events.
SuppressWithPlainTextCommentFilter.Suppression	The class which represents the suppression.
SuppressWithPlainTextCommentFilter.SuppressionType	Enum which represents the type of the suppression.
SwitchHandler	Handler for switch statements.
SwitchRuleHandler	Handler for switch rules.
SynchronizedHandler	Handler for synchronized statements.
TagInfo	Value object for storing data about a parsed tag.
TagParser	Helper class used to parse HTML tags or generic type identifiers from a single-line of text.
TagParser.Point	Represents current position in the text.
TextBlock	A block of text from an input file that does not necessarily have any grammatical structure.
ThreadModeSettings	Thread mode settings for the checkstyle modules.
ThrowsCountCheck	Restricts throws statements to a specified count.
TodoCommentCheck	Checks for TODO: comments.
TokenTypes	Contains the constants for all the tokens contained in the Abstract Syntax Tree.
TokenUtil	Contains utility methods for tokens.
TrailingCommentCheck	The check to ensure that lines with code do not end with comment.
TranslationCheck	Ensures the correct translation of code by checking property files for consistency regarding their keys.
TranslationCheck.ResourceBundle	Class which represents a resource bundle.
TreeTable	This example shows how to create a simple TreeTable component, by using a JTree as a renderer (and editor) for the cells in a particular column in the JTable.
TreeTableCellRenderer	A TreeCellRenderer that displays a JTree.
TreeTableModelAdapter	This is a wrapper class takes a TreeTableModel and implements the table model interface.
TreeWalker	Responsible for walking an abstract syntax tree and notifying interested checks at each node.
TreeWalker.AstState	State of AST.
TreeWalkerAuditEvent	Raw TreeWalker event for audit.
TreeWalkerFilter	An interface for filtering TreeWalkerAuditEvent.
TryHandler	Handler for try blocks.
TypecastParenPadCheck	Checks the policy on the padding of parentheses for typecasts.
TypeNameCheck	Checks that type names conform to a specified pattern.
UncommentedMainCheck	Detects uncommented main methods.
UniquePropertiesCheck	Detects duplicated keys in properties files.
UniquePropertiesCheck.UniqueProperties	Properties subclass to store duplicated property keys in a separate map.
UnmodifiableCollectionUtil	Note: it simply wraps the existing JDK methods to provide a workaround for Pitest survival on mutation for removal of immutable wrapping, see #13127 for more details.
UnnecessaryParenthesesCheck	Checks if unnecessary parentheses are used in a statement or expression.
UnnecessarySemicolonAfterOuterTypeDeclarationCheck	Checks if unnecessary semicolon is used after type declaration.
UnnecessarySemicolonAfterTypeMemberDeclarationCheck	Checks if unnecessary semicolon is used after type member declaration.
UnnecessarySemicolonInEnumerationCheck	Checks if unnecessary semicolon is in enum definitions.
UnnecessarySemicolonInTryWithResourcesCheck	Checks if unnecessary semicolon is used in last resource declaration.
UnusedCatchParameterShouldBeUnnamedCheck	Ensures that catch parameters that are not used are declared as an unnamed variable.
UnusedCatchParameterShouldBeUnnamedCheck.CatchParameterDetails	Maintains information about the catch parameter.
UnusedImportsCheck	Checks for unused import statements.
UnusedImportsCheck.Frame	Holds the names of referenced types and names of declared inner types.
UnusedLambdaParameterShouldBeUnnamedCheck	Ensures that lambda parameters that are not used are declared as an unnamed variable.
UnusedLambdaParameterShouldBeUnnamedCheck.LambdaParameterDetails	Maintains information about the lambda parameter.
UnusedLocalVariableCheck	Checks that a local variable is declared and/or assigned, but not used.
UnusedLocalVariableCheck.TypeDeclDesc	Maintains information about the type declaration.
UnusedLocalVariableCheck.VariableDesc	Maintains information about the variable.
UpperEllCheck	Checks that long constants are defined with an upper ell.
VariableDeclarationUsageDistanceCheck	Checks the distance between declaration of variable and its first usage.
Violation	Represents a violation that can be localised.
ViolationMessagesMacro	A macro that inserts a list of the violation messages.
VisibilityModifierCheck	Checks visibility of class members.
WhenShouldBeUsedCheck	Ensures that when is used instead of a single if statement inside a case block.
WhileHandler	Handler for while loops.
WhitespaceAfterCheck	Checks that a token is followed by whitespace, with the exception that it does not check for whitespace after the semicolon of an empty for iterator.
WhitespaceAroundCheck	Checks that a token is surrounded by whitespace.
WrapOption	Represents the options for wrapping on an operator.
WriteTagCheck	Requires user defined Javadoc tag to be present in Javadoc comment with defined format.
XdocsPropertyType	The type of property used in documentation and configuration files for clarification of the user-friendly type.
XdocsTemplateParser	Parser for Checkstyle's xdoc templates.
XdocsTemplateSink	A sink for Checkstyle's xdoc templates.
XdocsTemplateSink.CustomPrintWriter	A Custom writer that only prints Unix-style newline character.
XdocsTemplateSinkFactory	Xdoc template implementation of the SinkFactory.
XmlLoader	Contains the common implementation of a loader, for loading a configuration from an XML file.
XmlLoader.LoadExternalDtdFeatureProvider	Used for setting specific for secure java installations features to SAXParserFactory.
XMLLogger	Simple XML logger.
XMLLogger.FileMessages	The registered file messages.
XmlMetaReader	Class having utilities required to read module details from an XML metadata file of a module.
XmlMetaWriter	Class to write module details object into an XML file.
XpathFileGeneratorAstFilter	Catches TreeWalkerAuditEvent and generates corresponding xpath query.
XpathFileGeneratorAuditListener	Generates suppressions.xml file, based on violations occurred.
XpathFilterElement	This filter element is immutable and processes TreeWalkerAuditEvent objects based on the criteria of file, check, module id, xpathQuery.
XpathQueryGenerator	Generates xpath queries.
XpathUtil	Contains utility methods for xpath.
YieldHandler	Handler for yield expression.