Basic Rules

The Basic Ruleset contains a collection of good practices which everyone should follow.

EmptyCatchBlock

Empty Catch Block finds instances where an exception is caught, but nothing is done. In most circumstances, this swallows an exception which should either be acted on or reported.

This rule is defined by the following XPath expression:


                  
    //TryStatement
    [@Catch='true']
    [FormalParameter/Type/Name[@Image != 'InterruptedException']]
    [FormalParameter/Type/Name[@Image != 'CloneNotSupportedException']]
    /Block[position() > 1]
    [count(*) = 0]
    [../@Finally='false' or following-sibling::Block]
                  
              

Here's an example of code that would trigger this rule:

 
  
    public void doSomething() {
      try {
        FileInputStream fis = new FileInputStream("/tmp/bugger");
      } catch (IOException ioe) {
          // not good
      }
    }
  
       

EmptyIfStmt

Empty If Statement finds instances where a condition is checked but nothing is done about it.

This rule is defined by the following XPath expression:


                  
                    //IfStatement/Statement/Block[count(*) = 0]
                  
              

Here's an example of code that would trigger this rule:

 
  
    if (absValue < 1) {
       // not good
    }
  
        

EmptyWhileStmt

Empty While Statement finds all instances where a while statement does nothing. If it is a timing loop, then you should use Thread.sleep() for it; if it's a while loop that does a lot in the exit expression, rewrite it to make it clearer.

This rule is defined by the following XPath expression:


                  
    //WhileStatement/Statement/Block[count(*) = 0]
                  
              

Here's an example of code that would trigger this rule:

 
  
  while (a == b) {
    // not good
  }
  
        

EmptyTryBlock

Avoid empty try blocks - what's the point?

This rule is defined by the following XPath expression:


                  
    //TryStatement/Block[1][count(*) = 0]
                  
              

Here's an example of code that would trigger this rule:

 
  
  // this is bad
  public void bar() {
      try {
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
  
       

EmptyFinallyBlock

Avoid empty finally blocks - these can be deleted.

This rule is defined by the following XPath expression:


                  
    //TryStatement[@Finally='true']/Block[position() = last()]
      [count(*) = 0]
                  
              

Here's an example of code that would trigger this rule:

 
  
  // this is bad
  public void bar() {
      try {
          int x=2;
      } finally {
      }
  }
  
       

EmptySwitchStatements

Avoid empty switch statements.

This rule is defined by the following XPath expression:


                  
    //SwitchStatement[count(*) = 1]
                  
              

Here's an example of code that would trigger this rule:

 
  
  public class Foo {
   public void bar() {
    int x = 2;
    switch (x) {
     // once there was code here
     // but it's been commented out or something
    }
   }
  }
  
       

JumbledIncrementer

Avoid jumbled loop incrementers - it's usually a mistake, and it's confusing even if it's what's intended.

This rule is defined by the following XPath expression:


                 
    //ForStatement[ForUpdate//Name/@Image = 
      ancestor::ForStatement/ForInit//VariableDeclaratorId/@Image]
                 
             

Here's an example of code that would trigger this rule:

 
 
 public class JumbledIncrementerRule1 {
  public void foo() {
   for (int i = 0; i < 10; i++) {
    for (int k = 0; k < 20; i++) {
     System.out.println("Hello");
    }
   }
  }
 }}
      

ForLoopShouldBeWhileLoop

Some for loops can be simplified to while loops - this makes them more concise.

This rule is defined by the following XPath expression:


                
    //ForStatement[count(*) > 1][not(ForInit)][not(ForUpdate)]
                
            

Here's an example of code that would trigger this rule:

 
  
  public class Foo {
      void bar() {
          for (;true;) true; // No Init or Update part, may as well be: while (true)
      }
  }
  
       

UnnecessaryConversionTemporaryRule

Avoid unnecessary temporaries when converting primitives to Strings

Here's an example of code that would trigger this rule:

 
  
    public String convert(int x) {
      // this wastes an object
      String foo = new Integer(x).toString();
      // this is better
      return Integer.toString(x);
    }
  
       

OverrideBothEqualsAndHashcodeRule

Override both public boolean Object.equals(Object other), and public int Object.hashCode(), or override neither. Even if you are inheriting a hashCode() from a parent class, consider implementing hashCode and explicitly delegating to your superclass.

This rule is defined by the following XPath expression:


                  
      //ClassDeclaration//MethodDeclarator
      [
      (@Image = 'equals'
          and count(FormalParameters/*) = 1
          and not(//MethodDeclarator[count(FormalParameters/*) = 0]
          [@Image = 'hashCode'])
       or
      (@Image='hashCode'
          and count(FormalParameters/*) = 0
          and not(//MethodDeclarator[count(FormalParameters//Type/Name
          [@Image = 'Object']) = 1]
          [@Image = 'equals']))
      )]
                  
              

Here's an example of code that would trigger this rule:

 
  
  // this is bad
  public class Bar {
      public boolean equals(Object o) {
          // do some comparison
      }
  }

  // and so is this
  public class Baz {
      public int hashCode() {
          // return some hash value
      }
  }

  // this is OK
  public class Foo {
      public boolean equals(Object other) {
          // do some comparison
      }
      public int hashCode() {
          // return some hash value
      }
  }
  
       

DoubleCheckedLockingRule

Partially created objects can be returned by the Double Checked Locking pattern when used in Java. An optimizing JRE may assign a reference to the baz variable before it creates the object the reference is intended to point to. For more details see http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double.html.

Here's an example of code that would trigger this rule:

 
  
  public class Foo {
      Object baz;
      Object bar() {
        if(baz == null) { //baz may be non-null yet not fully created
          synchronized(this){
            if(baz == null){
              baz = new Object();
            }
          }
        }
        return baz;
      }
  }
  
       

ReturnFromFinallyBlock

Avoid returning from a finally block - this can discard exceptions.

This rule is defined by the following XPath expression:


                  
    //TryStatement[@Finally='true']/Block[position() = last()]//ReturnStatement
                  
              

Here's an example of code that would trigger this rule:

 
  
public class Bar {
 public String bugga() {
  try {
   throw new Exception( "My Exception" );
  } catch (Exception e) {
   throw e;
  } finally {
   return "A. O. K."; // Very bad.
  }
 }
}