Package com.puppycrawl.tools.checkstyle.checks.design

Class FinalClassCheck

java.lang.Object
com.puppycrawl.tools.checkstyle.AbstractAutomaticBean
com.puppycrawl.tools.checkstyle.api.AbstractViolationReporter
com.puppycrawl.tools.checkstyle.api.AbstractCheck
com.puppycrawl.tools.checkstyle.checks.design.FinalClassCheck
All Implemented Interfaces:
Configurable, Contextualizable
public class FinalClassCheck extends AbstractCheck
Ensures that identifies classes that can be effectively declared as final are explicitly marked as final. The following are different types of classes that can be identified:
  1. Private classes with no declared constructors.
  2. Classes with any modifier, and contains only private constructors.

Classes are skipped if:

  1. Class is Super class of some Anonymous inner class.
  2. Class is extended by another class in the same file.

Parent is com.puppycrawl.tools.checkstyle.TreeWalker

Violation Message Keys:

  • final.class
Since:
3.1

  • Field Details

  • Constructor Details

  • Method Details

    • getDefaultTokens

      public int[] getDefaultTokens()
      Description copied from class: AbstractCheck
      Returns the default token a check is interested in. Only used if the configuration for a check does not define the tokens.
      Specified by:
      getDefaultTokens in class AbstractCheck
      Returns:
      the default tokens
      See Also:

    • getAcceptableTokens

      public int[] getAcceptableTokens()
      Description copied from class: AbstractCheck
      The configurable token set. Used to protect Checks against malicious users who specify an unacceptable token set in the configuration file. The default implementation returns the check's default tokens.
      Specified by:
      getAcceptableTokens in class AbstractCheck
      Returns:
      the token set this check is designed for.
      See Also:

    • getRequiredTokens

      public int[] getRequiredTokens()
      Description copied from class: AbstractCheck
      The tokens that this check must be registered for.
      Specified by:
      getRequiredTokens in class AbstractCheck
      Returns:
      the token set this must be registered for.
      See Also:

    • beginTree

      public void beginTree(DetailAST rootAST)
      Description copied from class: AbstractCheck
      Called before the starting to process a tree. Ideal place to initialize information that is to be collected whilst processing a tree.
      Overrides:
      beginTree in class AbstractCheck
      Parameters:
      rootAST - the root of the tree

    • visitToken

      public void visitToken(DetailAST ast)
      Description copied from class: AbstractCheck
      Called to process a token.
      Overrides:
      visitToken in class AbstractCheck
      Parameters:
      ast - the token to process

    • visitClass

      private void visitClass(DetailAST ast)
      Called to process a type definition.
      Parameters:
      ast - the token to process

    • visitCtor

      private void visitCtor(DetailAST ast)
      Called to process a constructor definition.
      Parameters:
      ast - the token to process

    • leaveToken

      public void leaveToken(DetailAST ast)
      Description copied from class: AbstractCheck
      Called after all the child nodes have been process.
      Overrides:
      leaveToken in class AbstractCheck
      Parameters:
      ast - the token leaving

    • shouldBeDeclaredAsFinal

      private static boolean shouldBeDeclaredAsFinal(FinalClassCheck.ClassDesc classDesc)
      Checks whether a class should be declared as final or not.
      Parameters:
      classDesc - description of the class
      Returns:
      true if given class should be declared as final otherwise false

    • registerExtendedClass

      private void registerExtendedClass(String qualifiedClassName, FinalClassCheck.ClassDesc currentClass)
      Register to outer super class of given classAst that given classAst is extending them.
      Parameters:
      qualifiedClassName - qualifies class name(with package) of the current class
      currentClass - class which outer super class will be informed about nesting subclass

    • registerAnonymousInnerClassToSuperClass

      private void registerAnonymousInnerClassToSuperClass(DetailAST literalNewAst, String outerTypeDeclName)
      Register to the super class of anonymous inner class that the given class is instantiated by an anonymous inner class.
      Parameters:
      literalNewAst - ast node of TokenTypes.LITERAL_NEW representing anonymous inner class
      outerTypeDeclName - Fully qualified name of the outer type declaration of anonymous inner class

    • getNearestClassWithSameName

      private Optional<FinalClassCheck.ClassDesc> getNearestClassWithSameName(String className, ToIntFunction<FinalClassCheck.ClassDesc> countProvider)
      Get the nearest class with same name.

      The parameter countProvider exists because if the class being searched is the super class of anonymous inner class, the rules of evaluation are a bit different, consider the following example- 

       
 public class Main {
     static class One {
         static class Two {
         }
     }

     class Three {
         One.Two object = new One.Two() { // Object of Main.Three.One.Two
                                          // and not of Main.One.Two
         };

         static class One {
             static class Two {
             }
         }
     }
 }
      If the Function countProvider hadn't used getAnonSuperTypeMatchingCount(java.lang.String, java.lang.String) to calculate the matching count then the logic would have falsely evaluated Main.One.Two to be the super class of the anonymous inner class.
      Parameters:
      className - name of the class
      countProvider - the function to apply to calculate the name matching count
      Returns:
      Optional of FinalClassCheck.ClassDesc object of the nearest class with the same name.

    • extractQualifiedTypeName

      private String extractQualifiedTypeName(DetailAST typeDeclarationAst)
      Extract the qualified type declaration name from given type declaration Ast.
      Parameters:
      typeDeclarationAst - type declaration for which qualified name is being fetched
      Returns:
      qualified name of a type declaration

    • getSuperClassName

      private static String getSuperClassName(DetailAST classAst)
      Get super class name of given class.
      Parameters:
      classAst - class
      Returns:
      super class name or null if super class is not specified

    • getAnonSuperTypeMatchingCount

      private static int getAnonSuperTypeMatchingCount(String patternTypeDeclaration, String typeDeclarationToBeMatched)
      Calculates and returns the type declaration matching count when classToBeMatched is considered to be super class of an anonymous inner class.

      Suppose our pattern class is Main.ClassOne and class to be matched is Main.ClassOne.ClassTwo.ClassThree then type declaration name matching count would be calculated by comparing every character, and updating main counter when we hit "." or when it is the last character of the pattern class and certain conditions are met. This is done so that matching count is 13 instead of 5. This is due to the fact that pattern class can contain anonymous inner class object of a nested class which isn't true in case of extending classes as you can't extend nested classes.

      Parameters:
      patternTypeDeclaration - type declaration against which the given type declaration has to be matched
      typeDeclarationToBeMatched - type declaration to be matched
      Returns:
      type declaration matching count