Naming Rules

The Naming Ruleset contains a collection of rules about names - too long, too short, and so forth.

ShortVariable

Since: PMD 0.3

Detects when a field, local, or parameter has a very short name.

This rule is defined by the following XPath expression:

                  
//VariableDeclaratorId[string-length(@Image) < 3]
 [not(ancestor::ForInit)]
 [not((ancestor::FormalParameter) and (ancestor::TryStatement))]
                  
              

Example:

                

public class Something {
  private int q = 15; // VIOLATION - Field
  public static void main( String as[] ) {  // VIOLATION - Formal
    int r = 20 + q; // VIOLATION - Local
    for (int i = 0; i < 10; i++) { // Not a Violation (inside FOR)
      r += q;
    }
  }
}

    
            

LongVariable

Since: PMD 0.3

Detects when a field, formal or local variable is declared with a long name.

This rule is defined by the following XPath expression:

                  
//VariableDeclaratorId[string-length(@Image) &gt; $minimum]
                  
              

Example:

                

public class Something {
  int reallyLongIntName = -3;  // VIOLATION - Field
  public static void main( String argumentsList[] ) { // VIOLATION - Formal
    int otherReallyLongName = -5; // VIOLATION - Local
    for (int interestingIntIndex = 0;  // VIOLATION - For
             interestingIntIndex < 10;
             interestingIntIndex ++ ) {
    }
}

    
            

This rule has the following properties:

NameDefault valueDescription
minimum 17 The variable length reporting threshold

ShortMethodName

Since: PMD 0.3

Detects when very short method names are used.

This rule is defined by the following XPath expression:

                  
//MethodDeclarator[string-length(@Image) &lt; 3]
                  
              

Example:

                

public class ShortMethod {
  public void a( int i ) { // Violation
  }
}

     
            

VariableNamingConventions

Since: PMD 1.2

A variable naming conventions rule - customize this to your liking. Currently, it checks for final variables that should be fully capitalized and non-final variables that should not include underscores.

This rule is defined by the following Java class: net.sourceforge.pmd.rules.VariableNamingConventions

Example:

                

public class Foo {
 public static final int MY_NUM = 0;
 public String myTest = "";
 DataModule dmTest = new DataModule();
}

        
            

This rule has the following properties:

NameDefault valueDescription
staticPrefix A prefix for static variables
staticSuffix A suffix for static variables
memberPrefix A prefix for member variables
memberSuffix A suffix for member variables

MethodNamingConventions

Since: PMD 1.2

Method names should always begin with a lower case character, and should not contain underscores.

This rule is defined by the following Java class: net.sourceforge.pmd.rules.MethodNamingConventions

Example:

                

public class Foo {
 public void fooStuff() {
 }
}

          
            

ClassNamingConventions

Since: PMD 1.2

Class names should always begin with an upper case character.

This rule is defined by the following Java class: net.sourceforge.pmd.rules.ClassNamingConventions

Example:

                

public class Foo {}

      
            

AbstractNaming

Since: PMD 1.4

Abstract classes should be named 'AbstractXXX'.

This rule is defined by the following XPath expression:

                    
//ClassOrInterfaceDeclaration
 [@Abstract='true' and @Interface='false']
 [not (starts-with(@Image,'Abstract'))]
                    
                

Example:

                

public abstract class Foo { // should be AbstractFoo
}

       
            

AvoidDollarSigns

Since: PMD 1.5

Avoid using dollar signs in variable/method/class/interface names.

This rule is defined by the following Java class: net.sourceforge.pmd.rules.naming.AvoidDollarSigns

Example:

                
   
 public class Fo$o {  // yikes!
 }
   
       
            

MethodWithSameNameAsEnclosingClass

Since: PMD 1.5

Non-constructor methods should not have the same name as the enclosing class.

This rule is defined by the following Java class: net.sourceforge.pmd.rules.MethodWithSameNameAsEnclosingClass

Example:

                
    
public class MyClass {
 // this is bad because it is a method
 public void MyClass() {}
 // this is OK because it is a constructor
 public MyClass() {}
}
    
       
            

SuspiciousHashcodeMethodName

Since: PMD 1.5

The method name and return type are suspiciously close to hashCode(), which may mean you are intending to override the hashCode() method.

This rule is defined by the following Java class: net.sourceforge.pmd.rules.naming.SuspiciousHashcodeMethodName

Example:

                
    
public class Foo {
 public int hashcode() {
 // oops, this probably was supposed to be hashCode
 }
}
    
       
            

SuspiciousConstantFieldName

Since: PMD 2.0

A field name is all in uppercase characters, which in Sun's Java naming conventions indicate a constant. However, the field is not final.

This rule is defined by the following XPath expression:


//ClassOrInterfaceDeclaration[@Interface='false']
 /ClassOrInterfaceBody/ClassOrInterfaceBodyDeclaration/FieldDeclaration
  [@Final='false']
  [VariableDeclarator/VariableDeclaratorId[upper-case(@Image)=@Image]]
 
                

Example:

                
    
public class Foo {
 // this is bad, since someone could accidentally
 // do PI = 2.71828; which is actualy e
 // final double PI = 3.16; is ok
 double PI = 3.16;
}
    
       
            

SuspiciousEqualsMethodName

Since: PMD 2.0

The method name and parameter number are suspiciously close to equals(Object), which may mean you are intending to override the equals(Object) method.

This rule is defined by the following XPath expression:

        
//MethodDeclarator[@Image = 'equals']
[   
    (count(FormalParameters/*) = 1
    and not (FormalParameters/FormalParameter/Type/ReferenceType/ClassOrInterfaceType
        [@Image = 'Object' or @Image = 'java.lang.Object'])
    or not (../ResultType/Type/PrimitiveType[@Image = 'boolean'])
    )  or  (
    count(FormalParameters/*) = 2
    and ../ResultType/Type/PrimitiveType[@Image = 'boolean']
    and FormalParameters//ClassOrInterfaceType[@Image = 'Object' or @Image = 'java.lang.Object']
    )
]
| //MethodDeclarator[@Image = 'equal']
[
    count(FormalParameters/*) = 1
    and FormalParameters/FormalParameter/Type/ReferenceType/ClassOrInterfaceType
        [@Image = 'Object' or @Image = 'java.lang.Object']
]           
                    

Example:

                
        
public class Foo {
 public int equals(Object o) {
 // oops, this probably was supposed to be boolean equals
 }
 public boolean equals(String s) {
 // oops, this probably was supposed to be equals(Object)
 }
 public boolean equals(Object o1, Object o2) {
 // oops, this probably was supposed to be equals(Object)
 }
}
        
        
            

AvoidFieldNameMatchingTypeName

Since: PMD 3.0

It is somewhat confusing to have a field name matching the declaring class name. This probably means that type and or field names could be more precise.

This rule is defined by the following Java class: net.sourceforge.pmd.rules.AvoidFieldNameMatchingTypeName

Example:

                

public class Foo extends Bar {
 // There's probably a better name for foo
 int foo;
}

      
            

AvoidFieldNameMatchingMethodName

Since: PMD 3.0

It is somewhat confusing to have a field name with the same name as a method. While this is totally legal, having information (field) and actions (method) is not clear naming.

This rule is defined by the following Java class: net.sourceforge.pmd.rules.AvoidFieldNameMatchingMethodName

Example:

                

public class Foo {
	Object bar;
	// bar is data or an action or both?
	void bar() {
	}
}

      
            

NoPackage

Since: PMD 3.3

Detects when a class or interface does not have a package definition.

This rule is defined by the following XPath expression:

                  
//ClassOrInterfaceDeclaration[count(preceding::PackageDeclaration) = 0]
                  
              

Example:

                

// no package declaration
public class ClassInDefaultPackage {
}

    
            

PackageCase

Since: PMD 3.3

Detects when a package definition contains upper case characters.

This rule is defined by the following XPath expression:

                      
//PackageDeclaration/Name[lower-case(@Image)!=@Image]
                      
                  

Example:

                
    
package com.MyCompany;  // <- should be lower case name
public class SomeClass {
}
    
        
            

MisleadingVariableName

Since: PMD 3.4

Detects when a non-field has a name starting with 'm_'. This usually indicates a field and thus is confusing.

This rule is defined by the following XPath expression:

                    
//VariableDeclaratorId
[starts-with(@Image, 'm_')]
[not (../../../FieldDeclaration)]
                    
                

Example:

                
  
  public class Foo {
    private int m_foo; // OK
    public void bar(String m_baz) {  // Bad
      int m_boz = 42; // Bad
    }
  }
  
      
            

BooleanGetMethodName

Since: PMD 4.0

Looks for methods named 'getX()' with 'boolean' as the return type. The convention is to name these methods 'isX()'.

This rule is defined by the following XPath expression:

                    
//MethodDeclaration[
MethodDeclarator[count(FormalParameters/FormalParameter) = 0 or $checkParameterizedMethods = 'true']
                [starts-with(@Image, 'get')]
and
ResultType/Type/PrimitiveType[@Image = 'boolean']
]

                

Example:

                
            
public boolean getFoo(); // bad
public boolean isFoo(); // ok
public boolean getFoo(boolean bar); // ok, unless checkParameterizedMethods=true
     
            

This rule has the following properties:

NameDefault valueDescription
checkParameterizedMethods

GenericsNaming

Since: PMD 4.2.6

Generics names should be a one letter long and upper case.

This rule is defined by the following XPath expression:

                    
//TypeDeclaration/ClassOrInterfaceDeclaration/TypeParameters/TypeParameter[
  string-length(@Image) &gt; 1 
  or
  string:upper-case(@Image) != @Image
]

                

Example:

                
            
public interface GenericDao<E extends BaseModel, K extends Serializable> extends BaseDao
{
   // This is ok...
}

public interface GenericDao<E extends BaseModel, K extends Serializable>
{
   // Also this
}

public interface GenericDao<e extends BaseModel, K extends Serializable>
{
   // 'e' should be an 'E'
}

public interface GenericDao<EF extends BaseModel, K extends Serializable>
{
   // 'EF' is not ok.
}