Naming RulesThe Naming Ruleset contains a collection of rules about names - too long, too short, and so forth. ShortVariableDetects when a field, local or parameter has a 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))] Here's an example of code that would trigger this rule: 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; } } } LongVariableDetects 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) > 12] Here's an example of code that would trigger this rule: 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 ++ ) { } } ShortMethodNameRuleDetects when very short method names are used. This rule is defined by the following XPath expression: //MethodDeclarator[string-length(@Image) < 3] Here's an example of code that would trigger this rule: public class ShortMethod { public void a( int i ) { // Violation } } VariableNamingConventionsRuleA variable naming conventions rule - customize this to your liking Final variables should be all caps Non-final variables should not include underscores Here's an example of code that would trigger this rule: public class Foo { public static final int MY_NUM = 0; public String myTest = ""; DataModule dmTest = new DataModule(); } MethodNamingConventionsMethod names should always begin with a lower case character, and should not contain underscores. Here's an example of code that would trigger this rule: public class Foo { public void fooStuff() { } } ClassNamingConventionsRuleClass names should always begin with an upper case character, and should not contain underscores. Here's an example of code that would trigger this rule: public class Foo {} AbstractNamingRuleAbstract classes should be named 'AbstractXXX'. This rule is defined by the following XPath expression: //ClassDeclaration[@Abstract='true'] /UnmodifiedClassDeclaration[starts-with(@Image,'Abstract') = 0] Here's an example of code that would trigger this rule: public abstract class Foo { // should be AbstractFoo } AvoidDollarSignsAvoid using dollar signs in variable/method/class/interface names. This rule is defined by the following XPath expression: //UnmodifiedClassDeclaration[contains(@Image, '$')] | //VariableDeclaratorId[contains(@Image, '$')] | //UnmodifiedInterfaceDeclaration[contains(@Image, '$')] | //MethodDeclarator[contains(@Image, '$')] Here's an example of code that would trigger this rule: public class Fo$o { // yikes! } MethodWithSameNameAsEnclosingClassNon-constructor methods should not have the same name as the enclosing class. This rule is defined by the following XPath expression: //UnmodifiedClassDeclaration[@Image = //MethodDeclarator/@Image] Here's an example of code that would trigger this rule: public class MyClass { // this is bad because it is a method public void MyClass() {} // this is OK because it is a constructor public MyClass() {} } SuspiciousHashcodeMethodNameThe method name and return type are suspiciously close to hashCode(), which may mean you are trying (and failing) to override the hashCode() method. This rule is defined by the following XPath expression: //MethodDeclaration [ResultType //PrimitiveType [@Image='int'] [//MethodDeclarator [@Image='hashcode' or @Image='HashCode' or @Image='Hashcode'] [not(FormalParameters/*)] Here's an example of code that would trigger this rule: public class Foo { public int hashcode() { // oops, this probably was supposed to be hashCode } } |