Java OOP Rules
Rules available in this category:
- Avoid_redundant_interface_implementations
- Avoid_initialising_constant_fields_with_non_static_final_values
- Field_value_is_always_constant_null
- Declare_methods_not_using_instance_members_static
- Avoid_JavaBeans_style_of_construction
- Avoid_calling_equals_of_Object_on_Arrays
- Remove_System_print_or_println_statements
- Avoid_this_instanceof
- Do_not_hide_inherited_fields
- Override_equals_if_overriding_compareTo
- Avoid_abstract_modifier_with_interface
- Do_not_hide_inherited_static_methods
- Always_call_super_constructor_explicitly
- Declare_only_private_constructors_in_utility_classes
- Avoid_exception_as_flow_control
- Do_not_expose_collection_type_fields
- Avoid_returning_internal_array
- Avoid_deep_inheritance_hierarchy
- Always_declare_instance_fields_private
- Do_not_override_private_methods
- Always_declare_constructors_protected_for_abstract_class
- Make_readResolve_writeReplace_protected_or_public
- Always_override_equals_with_same_signature
- Avoid_suspicious_version_of_hashcode
- Provide_private_default_constructor_in_utility_classes
- Avoid_redundant_finalizers
- Avoid_synchronize_on_lock_implementation
- Avoid_misleading_class_name
- Use_interface_references_to_collection
- Avoid_instanceof_checks_in_catch_clause
- Avoid_nested_inner_classes
- Avoid_empty_body_for_implemented_methods
- Avoid_abstract_class_without_abstract_method
- 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.