AppPerfect

Java OOP Rules

Rules available in this category:

  1. Avoid_redundant_interface_implementations
  2. Avoid_initialising_constant_fields_with_non_static_final_values
  3. Field_value_is_always_constant_null
  4. Declare_methods_not_using_instance_members_static
  5. Avoid_JavaBeans_style_of_construction
  6. Avoid_calling_equals_of_Object_on_Arrays
  7. Remove_System_print_or_println_statements
  8. Avoid_this_instanceof
  9. Do_not_hide_inherited_fields
  10. Override_equals_if_overriding_compareTo
  11. Avoid_abstract_modifier_with_interface
  12. Do_not_hide_inherited_static_methods
  13. Always_call_super_constructor_explicitly
  14. Declare_only_private_constructors_in_utility_classes
  15. Avoid_exception_as_flow_control
  16. Do_not_expose_collection_type_fields
  17. Avoid_returning_internal_array
  18. Avoid_deep_inheritance_hierarchy
  19. Always_declare_instance_fields_private
  20. Do_not_override_private_methods
  21. Always_declare_constructors_protected_for_abstract_class
  22. Make_readResolve_writeReplace_protected_or_public
  23. Always_override_equals_with_same_signature
  24. Avoid_suspicious_version_of_hashcode
  25. Provide_private_default_constructor_in_utility_classes
  26. Avoid_redundant_finalizers
  27. Avoid_synchronize_on_lock_implementation
  28. Avoid_misleading_class_name
  29. Use_interface_references_to_collection
  30. Avoid_instanceof_checks_in_catch_clause
  31. Avoid_nested_inner_classes
  32. Avoid_empty_body_for_implemented_methods
  33. Avoid_abstract_class_without_abstract_method
  34. Do_not_override_nonabstract_methods_with_abstract_methods
Rule 1: Avoid_redundant_interface_implementations

Severity:  Medium
Rule:  Avoid declaring that the class implements an interface which is already implemented by its superclass.
Reason:  Avoid declaring that the class implements an interface which is already implemented by its superclass.

Usage Example: 

interface MyInterface
{
void aMethod();
}

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

//...
}

class SubClass extends SuperClass implements MyInterface //VIOLATION
{
//....
}

Should be written as:

interface MyInterface
{
void aMethod();
}

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

//...
}

class SubClass extends SuperClass // CORRECTION
{
//....
}

Reference:  Reference not available.

Rule 2: Avoid_initialising_constant_fields_with_non_static_final_values

Severity:  Medium
Rule:  It is preferrable to initialise constant fields with constant literals to avoid confusion.
Reason:  It is preferrable to initialise constant fields with constant literals to avoid confusion.

Usage Example: 

public class AvoidInitialisingConstantFieldsWithNonStaticFinalValues 
{
 static int v1 = 7;
 static final int v2 = v1 + 1; // VIOLATION
}

Should be written as:

public class AvoidInitialisingConstantFieldsWithNonStaticFinalValues 
{
 static int v1 = 7;
 static final int v2 = 8; // CORRECTION
}

Reference:  No references available.

Rule 3: Field_value_is_always_constant_null

Severity:  Medium
Rule:  The field value is always null. Check for errors, or remove if it is useless.
Reason:  The field value is always null. Check for errors, or remove if it is useless.

Usage Example: 

public class Test
{
Object b; // VIOLATION

Test()
{
b = null;
}

public void aMethod()
{
if (b != null)
{
b.toString();
}
}
}

Should be written as:


		

Reference:  No references available.

Rule 4: Declare_methods_not_using_instance_members_static

Severity:  Low
Rule:  Redeclare methods as static if not using instance class members.
Reason:  Redeclare methods as static if not using instance class members.

Usage Example: 

package com.rule;

public class Declare_methods_not_using_instance_members_static_violation 
{
//...

public double mean(int[] p)// Violation 
{
int sum = 0;  // sum of all the elements
for (int i=0; i<p.length; i++) 
{
sum += p[i];
}
return ((double)sum) / p.length;

}

Should be written as:

package com.rule;

public class Declare_methods_not_using_instance_members_static_correction
{
//...

public static double mean(int[] p)// Correction 
{
int sum = 0;  // sum of all the elements
for (int i=0; i<p.length; i++) 
{
sum += p[i];
}
return ((double)sum) / p.length;

}

Reference:  http://leepoint.net/notes-java/flow/methods/50static-methods.html

Rule 5: Avoid_JavaBeans_style_of_construction

Severity:  Medium
Rule:  Avoid JavaBeans style of construction.
Reason:  Avoid JavaBeans style of construction.

Usage Example: 

package com.rule;
public class Avoid_JavaBeans_style_of_construction_violation // VIOLATION
{
private int i;
public Avoid_JavaBeans_style_of_construction_violation()
{
}
public void setI(int ii)
{
i = ii;
}
public static void main(String[] args)
{
Avoid_JavaBeans_style_of_construction_violation a = new Avoid_JavaBeans_style_of_construction_violation();
a.setI(0);
}
}

Should be written as:

package com.rule;
public class Avoid_JavaBeans_style_of_construction_correction // CORRECTION
{
private int i;
public Avoid_JavaBeans_style_of_construction_violation(int ii)
{
i = ii;
}
public void setI(int ii)
{
i = ii;
}
public static void main(String[] args)
{
Avoid_JavaBeans_style_of_construction_correction a = new Avoid_JavaBeans_style_of_construction_correction(0);
}
}

Reference:  http://www.javapractices.com/Topic84.cjp

Rule 6: Avoid_calling_equals_of_Object_on_Arrays

Severity:  High
Rule:  Avoid calling equals() of java.lang.Object on Arrays.
Reason:  Avoid calling equals() of java.lang.Object on Arrays.

Usage Example: 

package com.rule;

public class Avoid_calling_equals_of_Object_on_Arrays_violation
{
public void foo(String str1[], String str2[])
{
if(str1.equals(str2))  // Violation
{
//...
}
}
}

Should be written as:

package com.rule;
import java.util.Arrays;

public class Avoid_calling_equals_of_Object_on_Arrays_correction
{
public void foo(String str1[], String str2[])
{
if(java.util.Arrays.equals(str1,str2)) // Correction 
{
//...
}
}
}

Reference:  Reference not available.

Rule 7: Remove_System_print_or_println_statements

Severity:  Low
Rule:  All debugging statements should be cleaned up before the product is released.
Reason:  All debugging statements should be cleaned up before the product is released.

Usage Example: 

public class MyClass
{

public int getMax(int i, int j, int default_num) 
{
int result = default_num;
if (i >= 0 && i > j) 
{
 result = i;

else if (j >= 0 && j >= i) 
{
  result = j;
}
System.out.println("result is : " + result); // VIOLATION
return result;
 }

}

Should be written as:

public class MyClass
{

public int getMax(int i, int j, int default_num) 
{
int result = default_num;
if (i >= 0 && i > j) 
{
 result = i;

else if (j >= 0 && j >= i) 
{
  result = j;
}
// CORRECTION
return result;
 }

}

Reference:  No references available.

Rule 8: Avoid_this_instanceof

Severity:  High
Rule:  Avoid this instanceof.
Reason:  Avoid this instanceof.

Usage Example: 

package com.rule;

class Avoid_this_instanceof_violation
{
public void foo()
{
if (this instanceof SubOne) // Violation
System.out.println("sub one");
}
}

class SubOne extends Avoid_this_instanceof_violation
{
//
}

Should be written as:

Instead of this, change the SubOne class to extend the foo() method.

Reference:  Reference Not Available.

Rule 9: Do_not_hide_inherited_fields

Severity:  Medium
Rule:  Avoid hiding inherited fields in child class.
Reason:  Avoid hiding inherited fields in child class.

Usage Example: 

package com.rule;

public class Do_not_hide_inherited_fields_violation implements Do_not_hide_inherited_fields_Interface_violation
{
protected int index;
public String name; // VIOLATION
private long id;
int[] values;
}

class Do_not_hide_inherited_fields_Child_violation extends Do_not_hide_inherited_fields_violation
{
private long index; // VIOLATION
protected Object name; // VIOLATION
short id; // VIOLATION
public Integer[] values;
String name2;
}

interface Do_not_hide_inherited_fields_Interface_violation
{
String name="NAME";
}

Should be written as:

Either rename the variables to use different names or remove the variables from child class and use the ones declared in parent class or interface.

Reference:  http://www.sys-con.com/story/feedback.cfm?storyid=46344

Rule 10: Override_equals_if_overriding_compareTo

Severity:  Medium
Rule:  Override equals if overriding compareTo.
Reason:  Override equals if overriding compareTo.

Usage Example: 

package com.rule;
classOverride_equals_if_overriding_compareTo_violation  implements Comparable
{
int i;
MyClas(int i)
{
this.i = i;
}

public boolean compareTo(Object o)
{
MyClass om = ...
if(i ==  om.i)
{
return 0;
}
if (i < om.i)
return -1

return 1;

}
}

Should be written as:

package com.rule;
classOverride_equals_if_overriding_compareTo_correction  implements Comparable
{
int i;
MyClas(int i)
{
this.i = i;
}

public boolean equals(Object o)// Correction
{
return i == ((MyClass) o).i
}

public boolean compareTo(Object o)
{
MyClass om = ...
if(i ==  om.i)
{
return 0;
}
if (i < om.i)
return -1

return 1;
}
}

Reference:  http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Comparable.html#compareTo(java.lang.Object)

Rule 11: Avoid_abstract_modifier_with_interface

Severity:  Low
Rule:  Avoid abstract modifier with interface.
Reason:  Avoid abstract modifier with interface.

Usage Example: 

package com.rule;
public abstract interface Avoid_abstract_modifier_with_interface_violation// Violation 
{
//...
}

Should be written as:

package com.rule;

public  interface Avoid_abstract_modifier_with_interface_correction// Correction 
{
//...
}

Reference:  http://java.sun.com/docs/books/tutorial/java/interpack/interfaceDef.html

Rule 12: Do_not_hide_inherited_static_methods

Severity:  Medium
Rule:  Avoid hiding the inherited static methods.
Reason:  Avoid hiding the inherited static methods.

Usage Example: 

package com.rule;

public class Do_not_hide_inherited_static_methods_violation
{
protected static void method()
{
}
private static void method2()
{
}
}

class Do_not_hide_inherited_static_methods_CHILD extends Do_not_hide_inherited_static_methods_violation
{
public static void method() // VIOLATION
{
}
protected static void method2()
{
}
}

Should be written as:

package com.rule;

public class Do_not_hide_inherited_static_methods_correction
{
protected static void method()
{
}
private static void method2()
{
}
}

class Do_not_hide_inherited_static_methods_CHILD extends Do_not_hide_inherited_static_methods_correction
{
public static void otherMethod() // CORRECTION
{
}
protected static void method2()
{
}
}

Reference:  Reference Not Available.

Rule 13: Always_call_super_constructor_explicitly

Severity:  Low
Rule:  Always call super-class constructor explicitly from sub-class constructor.
Reason:  Always call super-class constructor explicitly from sub-class constructor.

Usage Example: 

package com.rule;

public class Always_call_super_constructor_explicitly_violation extends Always_call_super_constructor_explicitly_super
{
public Always_call_super_constructor_explicitly_violation() // VIOLATION
{
}
}

class Always_call_super_constructor_explicitly_super
{
}

Should be written as:

package com.rule;

public class Always_call_super_constructor_explicitly_correction extends Always_call_super_constructor_explicitly_super
{
public Always_call_super_constructor_explicitly_correction() 
{
super(); // CORRECTION
}
}

class Always_call_super_constructor_explicitly_super
{
}

Reference:  http://www.bluej.org/objects-first/styleguide.html

Rule 14: Declare_only_private_constructors_in_utility_classes

Severity:  Medium
Rule:  The utility class should contain only private constructor.
Reason:  The utility class should contain only private constructor.

Usage Example: 

package com.rule;

public class Declare_only_private_constructors_in_utility_classes_violation
{
static int ID = 12345;
static String name = "Declare_only_private_constructors_in_utility_classes_violation";

static String getName()
{
return name;
}

Declare_only_private_constructors_in_utility_classes_violation() // VIOLATION
{
}

private Declare_only_private_constructors_in_utility_classes_violation(int id)
{
ID = id;
}
}

Should be written as:

package com.rule;

public class Declare_only_private_constructors_in_utility_classes_correction
{
static int ID = 12345;
static String name = "Declare_only_private_constructors_in_utility_classes_correction";

static String getName()
{
return name;
}

private Declare_only_private_constructors_in_utility_classes_correction() // CORRECTION
{
}

private Declare_only_private_constructors_in_utility_classes_correction(int id)
{
ID = id;
}
}

Reference:  http://www.devx.com/tips/Tip/14829
http://www.cs.umd.edu/class/spring2003/cmsc433/joint/EffectiveProgramming.pdf

Rule 15: Avoid_exception_as_flow_control

Severity:  High
Rule:  Avoid exception throwing as flow control.
Reason:  Avoid exception throwing as flow control.

Usage Example: 

package com.rule

class Avoid_exception_as_flow_control
{
void method()
{
try
{
while(condition1)
{
while(condition2)
{
if (condition3)
{
throw new MyException();
}
}
}
}
catch(MyException me)
{
//do nothing
}

//some other code
}
}

Should be written as:


		

Reference:  Reference Not Available

Rule 16: Do_not_expose_collection_type_fields

Severity:  High
Rule:  The private collection type fields should not be exposed.
Reason:  The private collection type fields should not be exposed.

Usage Example: 

package com.rule;

import java.util.ArrayList;

public class Do_not_expose_collection_type_fields_violation
{
private ArrayList alList = new ArrayList();

public ArrayList getList()
{
return alList; // VIOLATION
}
}

Should be written as:

package com.rule;

import java.util.ArrayList;

public class Do_not_expose_collection_type_fields_correction
{
private ArrayList alList = new ArrayList();

public Object getObject(int i) // CORRECTION
{
return alList.get(i);
}

public void addObject(int i, Object o) // CORRECTION
{
alList.add(i, o);
}

public Object removeObject(int i) // CORRECTION
{
return alList.remove(i);
}
}

Reference:  http://www.ambysoft.com/javaCodingStandards.pdf (pt 3.4.2.3)

Rule 17: Avoid_returning_internal_array

Severity:  High
Rule:  Internal arrays should not be exposed.
Reason:  Internal arrays should not be exposed.

Usage Example: 

public class AvoidReturningInternalArray
{
String[] arr;

public String[] getArr()
{
return arr; // VIOLATION
}

public String[] getThisArr()
{
return this.arr; // VIOLATION
}

public String[] getArrBad()
{
String[] arr;
return this.arr; // VIOLATION
}
}

Should be written as:

Return a copy of the array instead.

Reference:  No references available.

Rule 18: Avoid_deep_inheritance_hierarchy

Severity:  Critical
Rule:  Avoid too deep inheritance hierarchy.
Reason:  Avoid too deep inheritance hierarchy.

Usage Example: 

package com.rule;
public class Avoid_deep_inheritance_hierarchy_violation 
{
}
class inherit1 extends Avoid_deep_inheritance_hierarchy_violation
{
}
class inherit2 extends inherit1
{
}
class inherit3 extends inherit2
{
}
class inherit4 extends inherit3
{
}
class inherit5 extends inherit4
{
}
class inherit6 extends inherit5// Violation
{
}

Should be written as:

Avoid too deep inheritance hierarchy.

Reference:  http://www.javapractices.com/Topic72.cjp

Rule 19: Always_declare_instance_fields_private

Severity:  High
Rule:  Always declare all instance variables of a class private.
Reason:  Always declare all instance variables of a class private.

Usage Example: 

package com.rule;

class Always_declare_instance_fields_private_violation
{
public int i; // VIOLATION
//...
Always_declare_instance_fields_private_violation()
{
i = 1;
}
}

Should be written as:

package com.rule;

class Always_declare_instance_fields_private_correction
{
private int i; //CORRECTION
//...

Always_declare_instance_fields_private_correction()
{
i = 1;
}
}

Reference:  http://java.sun.com/docs/codeconv/html/CodeConventions.doc9.html#177

Rule 20: Do_not_override_private_methods

Severity:  Medium
Rule:  Avoid writing a method with same signature as that of a private method in parent classes.
Reason:  Avoid writing a method with same signature as that of a private method in parent classes.

Usage Example: 

package medium.oops;

public class Do_not_override_private_methods_violation
{
private void method()
{
}
}

class Do_not_override_private_methods_CHILD extends Do_not_override_private_methods_violation
{
public String method() // VIOLATION
{
return "abcde";
}
}

Should be written as:

package medium.oops;

public class Do_not_override_private_methods_correction
{
private void method()
{
}
}

class Do_not_override_private_methods_CHILD extends Do_not_override_private_methods_correction
{
public String otherMethod() // CORRECTION
{
return "abcde";
}
}

Reference:  Reference Not Available.

Rule 21: Always_declare_constructors_protected_for_abstract_class

Severity:  Low
Rule:  All constructors in an abstract class should be protected.
Reason:  All constructors in an abstract class should be protected.

Usage Example: 

package com.rule;

public abstract class Always_declare_constructors_protected_for_abstract_class_violation
{
public Always_declare_constructors_protected_for_abstract_class_violation() // VIOLATION
{
}
}

Should be written as:

package com.rule;

public abstract class Always_declare_constructors_protected_for_abstract_class_correction
{
protected Always_declare_constructors_protected_for_abstract_class_correction() // CORRECTION
{
}
}

Reference:  Reference not available.

Rule 22: Make_readResolve_writeReplace_protected_or_public

Severity:  Medium
Rule:  Declare readResolve and writeReplace method protected or public.
Reason:  Declare readResolve and writeReplace method protected or public.

Usage Example: 

package com.rule;

import java.io.ObjectStreamException;
import java.io.Serializable;

public class Make_readResolve_writeReplace_protected_violation implements Serializable
{
private Object readResolve () throws ObjectStreamException // VIOLATION
{
return null; // return the proper object here
}
  
private Object writeReplace () throws ObjectStreamException // VIOLATION
{
return null; // return the proper object here


}

Should be written as:

package com.rule;

import java.io.ObjectStreamException;
import java.io.Serializable;

public class Make_readResolve_writeReplace_protected_correction implements Serializable
{
protected Object readResolve () throws ObjectStreamException // CORRECTION
{
return null; // return the proper object here
}
  
protected Object writeReplace () throws ObjectStreamException // CORRECTION
{
return null; // return the proper object here


}

Reference:  No reference available.

Rule 23: Always_override_equals_with_same_signature

Severity:  High
Rule:  Avoid covariant version of equals.
Reason:  Avoid covariant version of equals.

Usage Example: 

package com.rule;

public class Avoid_covariant_version_of_equals_violation
{
public void foo()
{
Super s1 = new Sub();
Super s2 = new Sub();
if(s1.equals(s2))
{
//...

}
}
class Sub extends Super
{
public boolean equals(Sub sub)// Violation 
{
return this == sub;
}
}

Should be written as:

package com.rule;

public class Avoid_covariant_version_of_equals_correction
{
public void foo()
{
Super s1 = new Sub();
Super s2 = new Sub();
if(s1.equals(s2))
{
//...
}
}
}
class Sub extends Super
{
public boolean equals(java.lang.Object sub)  // Correction
{
return this == sub;
}
}

Reference:  Reference not available.

Rule 24: Avoid_suspicious_version_of_hashcode

Severity:  High
Rule:  Avoid suspicious version of Hashcode.
Reason:  Avoid suspicious version of Hashcode.

Usage Example: 

package com.rule;

public class Avoid_suspicious_version_of_hashcode
{
public int hashcode() //Violation
{
 return int;
}
public String hashCode(String s) //Violation
{
 return int;
}
public int hashcode(String s) //Violation
{
return int;
}
public int HASHCODE() //Violation
{
 return int;
}
}

Should be written as:


		

Reference:  Reference not available.

Rule 25: Provide_private_default_constructor_in_utility_classes

Severity:  Medium
Rule:  The utility class should contain private default constructor.
Reason:  The utility class should contain private default constructor.

Usage Example: 

package com.rule;

public class Provide_private_default_constructor_in_utility_classes_violation // VIOLATION
{
static int ID = 12345;
static String name = "Provide_private_default_constructor_in_utility_classes_violation";

static String getName()
{
return name;
}
}

Should be written as:

package com.rule;

public class Provide_private_default_constructor_in_utility_classes_correction
{
static int ID = 12345;
static String name = "Provide_private_default_constructor_in_utility_classes_correction";

static String getName()
{
return name;
}

private Provide_private_default_constructor_in_utility_classes_correction() // CORRECTION
{
}
}

Reference:  http://www.devx.com/tips/Tip/14829
http://www.cs.umd.edu/class/spring2003/cmsc433/joint/EffectiveProgramming.pdf

Rule 26: Avoid_redundant_finalizers

Severity:  Medium
Rule:  If a finalize method does nothing besides call super.finalize, it is redundant and can be removed.
Reason:  If a finalize method does nothing besides call super.finalize, it is redundant and can be removed.

Usage Example: 

public class Test
{
 protected void finalize() throws Throwable  // VIOLATION
 {
  super.finalize();
 }
}

Should be written as:

public class Test
{
 // FIXED
}

Reference:  Not Available.

Rule 27: Avoid_synchronize_on_lock_implementation

Severity:  Low
Rule:  Avoid synchronize on Lock implementation.
Reason:  Avoid synchronize on Lock implementation.

Usage Example: 

package com.rule;
import java.util.concurrent.locks.Lock;

public class Avoid_synchronize_on_lock_implementation_violation implements Lock
{
public void foo()
{
synchronized(this) violation
{
//...
}
}

}

Should be written as:

package com.rule;
import java.util.concurrent.locks.Lock;

public class Avoid_synchronize_on_lock_implementation_correction implements Lock
{
public void foo()
{
this.lock(); // Correction
try
{
//...
}
catch() {}
finally
{
this.unlock();
}

}

}

Reference:  http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/locks/Lock.html

Rule 28: Avoid_misleading_class_name

Severity:  Low
Rule:  Class does not extends java.lang.Exception, but class name has the word Exceptiopn at the end.
Reason:  Class does not extends java.lang.Exception, but class name has the word Exceptiopn at the end.

Usage Example: 

public class Avoid_naming_class_as_Exception // VIOLATION
{
// ....
}

Should be written as:


		

Reference:  http://www.hacknot.info/hacknot/action/showEntry?eid=48

Rule 29: Use_interface_references_to_collection

Severity:  Low
Rule:  Use interface references to collection.
Reason:  Use interface references to collection.

Usage Example: 

package com.rule;
import java.util.HashMap;

public class Use_interface_reference_to_collection_violation
{
  public void foo()
{
HashMap hm = new HashMap();// Violation
//...
}
}

Should be written as:

package com.rule;
import java.util.Map;
import java.util.HashMap;

public class Use_interface_reference_to_collection_correction
{
   public void foo()
{
Map hm = new HashMap();// Correction
}
}

Reference:  http://www . javapractices.com/Topic26.cjp

Rule 30: Avoid_instanceof_checks_in_catch_clause

Severity:  High
Rule:  Avoid Instanceof Checks In Catch Clause.
Reason:  Avoid Instanceof Checks In Catch Clause.

Usage Example: 

package com.rule;

public class Avoid_Instanceof_Checks_In_Catch_Clause
{
try
{
// Some Code...
}
catch (Exception e)
{
if (e instanceof IOException) // Violation
{
//Handle IOException
}
else if (e instanceof NumberFormatException) // Violation
{
//Handle NumberFormatException
}
}
}

Should be written as:

package com.rule;

public class Avoid_Instanceof_Checks_In_Catch_Clause
{
try
{
// Some Code...
}
catch (IOException e)
{
//Handle IOException
}
catch (NumberFormatException e)
{
//Handle NumberFormatException
}
}

Reference:  Reference not available.

Rule 31: Avoid_nested_inner_classes

Severity:  Medium
Rule:  Do not create deeper nesting of inner / anonymous classes.
Reason:  Do not create deeper nesting of inner / anonymous classes.

Usage Example: 

package com.rule;

public class Avoid_nested_inner_classes_violation
{
static class Avoid_nested_inner_classes_INNER1
{
class Avoid_nested_inner_classes_INNER2
{
class Avoid_nested_inner_classes_INNER3 // VIOLATION
{
class Avoid_nested_inner_classes_INNER4 // VIOLATION
{
class Avoid_nested_inner_classes_INNER5 // VIOLATION
{
}
}
}
}
}
}

Should be written as:

Remove the inner classes and make them seperate classes.

Reference:  Reference Not Available.

Rule 32: Avoid_empty_body_for_implemented_methods

Severity:  Medium
Rule:  If a class implements an interface it should provide non-empty implementation of all the methods.
Reason:  If a class implements an interface it should provide non-empty implementation of all the methods.

Usage Example: 

package com.rule;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Avoid_empty_body_for_implemented_methods_violation implements ActionListener
{

public void actionPerformed(ActionEvent e) // VIOLATION
{
}

}

Should be written as:

package com.rule;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public abstract class Avoid_empty_body_for_implemented_methods_correction implements ActionListener
{

public abstract void actionPerformed(ActionEvent e); // CORRECTION

}

Reference:  No reference available.

Rule 33: Avoid_abstract_class_without_abstract_method

Severity:  Medium
Rule:  A class without any abstract method should not be declared abstract
Reason:  A class without any abstract method should not be declared abstract

Usage Example: 

package com.rule;

abstract class Avoid_abstract_class_without_abstract_method_violation // VIOLATION
{
void method
{
//...
}
}

Should be written as:

package com.rule;

abstract class Avoid_abstract_class_without_abstract_method_violation
{
abstract void method(); // CORRECTION
}

Reference:  Reference Not Available.

Rule 34: Do_not_override_nonabstract_methods_with_abstract_methods

Severity:  Low
Rule:  A non-abstract method should not be overriden with abstract methods.
Reason:  A non-abstract method should not be overriden with abstract methods.

Usage Example: 

package com.rule;

public class Do_not_override_nonabstract_methods_with_abstract_methods
{
public void method()
{
}
}

abstract class Do_not_override_nonabstract_methods_with_abstract_methods_CHILD
extends Do_not_override_nonabstract_methods_with_abstract_methods
{
public abstract void method(); // VIOLATION
}

Should be written as:

Never override a non-abstract method with an abstract method. Instead you can use some other name for the abstract method.

Reference:  No reference available.