AppPerfect

UnusedCode Rules (UnusedCode)

Rules available in this category:

  1. Avoid_unused_private_methods
  2. Avoid_unused_public_or_protected_methods
  3. Avoid_unused_package_private_methods
  4. Avoid_unused_public_or_protected_classes
  5. Avoid_unused_package_private_classes
  6. Avoid_unused_public_or_protected_fields
  7. Avoid_unused_package_private_fields
  8. Avoid_unused_labels
  9. Avoid_unused_methods_in_anonymous_class
  10. Avoid_empty_switch_statement
  11. Do_not_explicitly_extend_class_from_Object
  12. Avoid_Unused_Imports
  13. Avoid_imports_from_same_package
  14. Avoid_unused_private_fields
  15. Avoid_unused_private_classes_and_interfaces
  16. Avoid_unreacheable_if_cases
  17. Avoid_useless_method_overriding
  18. Always_use_caught_exception
  19. Avoid_unused_parameters
  20. Avoid_unused_local_variables
Rule 1: Avoid_unused_private_methods

Severity:  Low
Rule:  Unused private methods should be removed.
Reason:  Unused private methods should be removed.

Usage Example: 

package com.rule;

class Avoid_unused_private_methods_violation
{
private void action() // VIOLATION
{
//...
}
public void method()
{
//...
}
}

Should be written as:

package com.rule;

class Avoid_unused_private_methods_correction
{
/*

private void action() // CORRECTION
{
//...
}
*/
public void method()
{
//...
}
}

Reference:  Reference Not Available.

Rule 2: Avoid_unused_public_or_protected_methods

Severity:  Low
Rule:  Unused public code might be accessed by attackers and that the code may implement features that bypass security.
Reason:  Unused public code might be accessed by attackers and that the code may implement features that bypass security.

Usage Example: 

public class Test
{
public void fubar()  // VIOLATION
{
//....
}
}

Should be written as:

public class Test
{
// FIXED (method removed)
}

Reference:  Not available.

Rule 3: Avoid_unused_package_private_methods

Severity:  Low
Rule:  Unused code might be accessed by attackers and that the code may implement features that bypass security.
Reason:  Unused code might be accessed by attackers and that the code may implement features that bypass security.

Usage Example: 

public class Test
{
void fubar()  // VIOLATION
{
//....
}
}

Should be written as:

public class Test
{
// FIXED (method removed)
}

Reference:  Not available.

Rule 4: Avoid_unused_public_or_protected_classes

Severity:  Low
Rule:  Unused public code might be accessed by attackers and that the code may implement features that bypass security.
Reason:  Unused public code might be accessed by attackers and that the code may implement features that bypass security.

Usage Example: 

public class Test // VIOLATION	
{

}

Should be written as:

// FIXED (class removed)

Reference:  Not available.

Rule 5: Avoid_unused_package_private_classes

Severity:  Low
Rule:  Unused code might be accessed by attackers and that the code may implement features that bypass security.
Reason:  Unused code might be accessed by attackers and that the code may implement features that bypass security.

Usage Example: 

class Test // VIOLATION		
{

}

Should be written as:

// FIXED (class removed)

Reference:  Not available.

Rule 6: Avoid_unused_public_or_protected_fields

Severity:  Low
Rule:  Unused public code might be accessed by attackers and that the code may implement features that bypass security.
Reason:  Unused public code might be accessed by attackers and that the code may implement features that bypass security.

Usage Example: 

public class Test
{
public int myField; // VIOLATION
}

Should be written as:

public class Test
{
// FIXED (field removed)
}

Reference:  Not available.

Rule 7: Avoid_unused_package_private_fields

Severity:  Low
Rule:  Unused code might be accessed by attackers and that the code may implement features that bypass security.
Reason:  Unused code might be accessed by attackers and that the code may implement features that bypass security.

Usage Example: 

public class Test
{
int myField; // VIOLATION
}

Should be written as:

public class Test
{
// FIXED (field removed)
}

Reference:  Not available.

Rule 8: Avoid_unused_labels

Severity:  Low
Rule:  Avoid unused labels.
Reason:  Avoid unused labels.

Usage Example: 

package com.rule;
public class Avoid_unused_labels_violation
{
public static void method()
{
lbl2 : // VIOLATION
{
// DO NOTHING
}
}
}

Should be written as:

package com.rule;
public class Avoid_unused_labels_correction
{
public static void method()
{
// CORRECTION
{
// DO NOTHING
}
}
}

Reference:  Reference Not Available.

Rule 9: Avoid_unused_methods_in_anonymous_class

Severity:  Medium
Rule:  It could either be unused code or a possible bug.
Reason:  It could either be unused code or a possible bug.

Usage Example: 

public class Test
{
public void fubar()
{
new SuperClass()
{

public void someMethod()
{
//...
}

public void uselessMethod() // VIOLATION
{
//...
}

};

new MyInterface()
{

public void someInterfaceMethod()
{
//...
}

public void anotherUselessMethod() // VIOLATION
{
//....
}

};
}
}

interface MyInterface
{
void someInterfaceMethod();
}

class SuperClass
{
public void someMethod()
{

}
}

Should be written as:

public class Test
{
public void fubar()
{
new SuperClass()
{

public void someMethod()
{
//...
}

// FIXED: method removed

};

new MyInterface()
{

public void someInterfaceMethod()
{
//...
}

// FIXED: method removed

};
}
}

interface MyInterface
{
void someInterfaceMethod();
}

class SuperClass
{
public void someMethod()
{

}
}

Reference:  Not Available.

Rule 10: Avoid_empty_switch_statement

Severity:  Low
Rule:  Do not use empty switch statements.
Reason:  Do not use empty switch statements.

Usage Example: 

package com.rule;
public class Avoid_empty_switch_statement_violation
{
public void method()
{
int month = 10;
switch (month)// Violation
{

}
}
}

Should be written as:

Avoid empty switch statements.

Reference:  Reference Not Available.

Rule 11: Do_not_explicitly_extend_class_from_Object

Severity:  Low
Rule:  Do not explicitly extend a class from java.lang.Object
Reason:  Do not explicitly extend a class from java.lang.Object

Usage Example: 

package com.rule;

public class Do_not_explicitly_extend_class_from_Object_violation  extends java.lang.Object  // Violation
{
}

Should be written as:

package com.rule;

public class Do_not_explicitly_extend_class_from_Object_correction// Correction
{
}

Reference:  http://www.cafeaulait.org/course/week4/33.html

Rule 12: Avoid_Unused_Imports

Severity:  Low
Rule:  Avoid importing classes which are not used.
Reason:  Avoid importing classes which are not used.

Usage Example: 

package com.rule;

import java.awt.*;  //voilation
import java.awt.Frame;
import javax.swing.*;  //violation
import java.awt.event.ActionListener; //violation

public class Avoid_unused_imports_violation
{
Frame f;
java.awt.event.ActionListener al = null;
public Avoid_unused_imports(Frame mf)
{
f = mf;
}
}

Should be written as:

package com.rule;

//import java.awt.*;  //correction
import java.awt.Frame;
//import javax.swing.*;  //correction
//import java.awt.event.ActionListener; //correction

public class Avoid_unused_imports_correction //correction
{
Frame f;
java.awt.event.ActionListener al = null;
public Avoid_unused_imports(Frame mf)
{
f = mf;
}
}

Reference:  Reference Not Available.

Rule 13: Avoid_imports_from_same_package

Severity:  Low
Rule:  Importing classes from the same package as the current class is redundant.
Reason:  Importing classes from the same package as the current class is redundant.

Usage Example: 

package myPackage.package1;

import myPackage.package1.*; // VIOLATION
import myPackage.package1.someClass; //VIOLATION

public class RedundantImport 
{
}

Should be written as:

package myPackage.package1;

//FIXED

public class RedundantImport 
{
}

Reference:  No references available.

Rule 14: Avoid_unused_private_fields

Severity:  Low
Rule:  Unused private fields should be removed.
Reason:  Unused private fields should be removed.

Usage Example: 

package com.rule;

class Avoid_unused_private_fields_violation
{
private int i; // VIOLATION
}

Should be written as:

package com.rule;

class Avoid_unused_private_fields_correction
{
//private int i; // CORRECTION

}

Reference:  Reference Not Available.

Rule 15: Avoid_unused_private_classes_and_interfaces

Severity:  Low
Rule:  Avoid unused private classes and interfaces.
Reason:  Avoid unused private classes and interfaces.

Usage Example: 

package com.rule;
public class Avoid_unused_private_classes_and_interfaces_violation
{
private class PrivateClass // VIOLATION
{
}
}

Should be written as:

package com.rule;
public class Avoid_unused_private_classes_and_interfaces_correction
{
// CORRECTION : private unused class removed
}

Reference:  Reference Not Available.

Rule 16: Avoid_unreacheable_if_cases

Severity:  Low
Rule:  These if-elseif cases are unreachable.
Reason:  These if-elseif cases are unreachable.

Usage Example: 

public class UnreachableIf
{
public String getGradeFromScore(int score) 
{
boolean b = true;
Object a = null;
  if (score< 50) 
{
  return "FAIL";
  }
else if (score>= 50) 
{
  return "PASS;
  }
  else if (score== 100) //VIOLATION

   return "PERFECT"
  }
  else // VIOLATION
{  
return "INVALID_SCORE";
  }
  if ( b )
  {
  //...
  }
  else if ( b == false )
  {
  //...
  }
  else // VIOLATION
  {
  //...
  }
  if ( a == null )
  {
  //...
  }
  else if ( a != null )
  {
  //...
  } 
  else // VIOLATION
  {
  //...
  }
}
}

Should be written as:

public class UnreachableIf
{
public String getGradeFromScore(int score) 
{
boolean b = true;
Object a = null;

  if (score>= 0 && score< 50) 
{
  return "FAIL";
  }
else if (score>= 50 && score< 100) 
{
  return "PASS;
}
  else if (score== 100)  // CORRECTION

   return "PERFECT"
  }
  else // CORRECTION

   return "INVALID_SCORE";
  }
    if ( b )
  {
  //...
  }
  else if ( b == false )
  {
  //...
  }
  if ( a == null )
  {
  //...
  }
  else if ( a != null )
  {
  //...
  } 
}

}

Reference:  No references available.

Rule 17: Avoid_useless_method_overriding

Severity:  Low
Rule:  Avoid overriding methods which just call the same method defined in the superclass.
Reason:  Avoid overriding methods which just call the same method defined in the superclass.

Usage Example: 

public class SuperClass
{
public void aMethod()
{
//...
}
}

public class SubClass extends SuperClass
{
public void aMethod() // VIOLATION
{
super.aMethod(); 
}
}

Should be written as:


		

Reference:  Reference not available.

Rule 18: Always_use_caught_exception

Severity:  Medium
Rule:  The caught exception should not be ignored.
Reason:  The caught exception should not be ignored.

Usage Example: 

package com.rule;

import java.net.MalformedURLException;
import java.net.URL;

public class Always_use_caught_exception_violation
{
public void method(String str)
{
try
{
URL url = new URL(str);
}
catch (MalformedURLException e) // VIOLATION
{
}
}
}

Should be written as:

package com.rule;

import java.net.MalformedURLException;
import java.net.URL;

public class Always_use_caught_exception_correction
{
public void method(String str)
{
try
{
URL url = new URL(str);
}
catch (MalformedURLException e)
{
System.out.println("Error occurred: " + e.getMessage());
}
}
}

Reference:  No reference available.

Rule 19: Avoid_unused_parameters

Severity:  Low
Rule:  An unused parameter in the method should be removed.
Reason:  An unused parameter in the method should be removed.

Usage Example: 

package com.rule;

class Avoid_unused_parameters_violation
{
public void method(int i) // VIOLATION
{
}
}

Should be written as:

package com.rule;

class Avoid_unused_parameters_correction
{
public void method() // CORRECTION
{
//...
}
}

Reference:  Reference Not Available.

Rule 20: Avoid_unused_local_variables

Severity:  Low
Rule:  An unused local variable should be removed.
Reason:  An unused local variable should be removed.

Usage Example: 

package com.rule;

class Avoid_unused_local_variables_violation
{
public void method()
{
final int ZERO = 0;
final int TEN = 10;

int i = ZERO;
int j = ZERO; // VIOLATION

for(int k=ZERO;i<TEN;i++) // VIOLATION
{
i++;
}
}
}

Should be written as:

package com.rule;

class Avoid_unused_local_variables_correction
{
public void method()
{
final int ZERO = 0;
final int TEN = 10;

int i = ZERO;
for(i = ZERO;i<TEN;i++)
{
i++;
}
// CORRECTION : Variables j and k have been removed, as there were never been used.
}
}

Reference:  Reference Not Available.