AppPerfect

J2ME Code

Rules available in this category:

  1. Avoid_array_length_in_loop_condition
  2. Avoid_unused_classes_that_are_subclassed_only_once
  3. Avoid_using_anonymous_classes_as_interface_implementors
  4. Always_catch_OutOfMemoryError_while_allocating_large_arrays
  5. Use_method_parameters_instead_of_returning_objects
  6. Avoid_overly_accessing_a_field
  7. Avoid_large_number_of_constant_initializations_of_primitive_arrays
Rule 1: Avoid_array_length_in_loop_condition

Severity:  High
Rule:  Avoid array.length in loop condition.
Reason:  Avoid array.length in loop condition.

Usage Example: 

package com.rule;

public class Avoid_array_length_in_loop_condition_violation
{
private void foo(int arr[])
{
for(int i=0; i<arr.length; i++) // Violation
{
//...
}
}
}

Should be written as:

package com.rule;

public class Avoid_array_length_in_loop_condition_correction
{
private void foo(int arr[])
{
int iSize = arr.length;  // Correction
for(int i=0; i<iSize; i++)
{
//...
}
}
}

Reference:  Reference not available.

Rule 2: Avoid_unused_classes_that_are_subclassed_only_once

Severity:  Medium
Rule:  Reducing the number of classes will reduce the application's overall source code size.
Reason:  Reducing the number of classes will reduce the application's overall source code size.

Usage Example: 

public class MyClass extends MyObject 
{
 private int myData;

 public void setMyData(int data) 
{
  myData = data;
 }

 public int getMyData() 
{
  return myData;
 }
}

abstract class MyObject  // VIOLATION

 public int hashCode() 
{
  return super.hashCode();
 }
}

Should be written as:

public class MyClass // FIXED

 private int myData;

 public void setMyData(int data) 
{
  myData = data;
 }

 public int getMyData() 
{
  return myData;
 }

 public int hashCode() 
{
  return super.hashCode();
 }
}

Reference:  http://developers.sun.com/techtopics/mobility/midp/ttips/appsize/

Rule 3: Avoid_using_anonymous_classes_as_interface_implementors

Severity:  Medium
Rule:  The number of allocated objects are reduced by re-using an existing instance of the enclosing class.
Reason:  The number of allocated objects are reduced by re-using an existing instance of the enclosing class.

Usage Example: 

public class MyClass extends Frame 
{
  private TextField text;

  public MyClass() 
 {
add(text = new TextField(), "Center");
pack();
setVisible(true);
text.addActionListener(new ActionListener() { // VIOLATION
 public void actionPerformed(ActionEvent event) 
{
  text.setText("");
 }
});
  }
}

Should be written as:

public class MyClass extends Frame implements ActionListener // FIXED
{
  private TextField text;

  /**
* Creates a new example object.
*/
  public MyClass()
 {
add(text = new TextField(), "Center");
pack();
setVisible(true);
text.addActionListener(this); // FIXED
  }

  public void actionPerformed(ActionEvent event) 
 {
text.setText("");
  }
}

Reference:  http://developers.sun.com/techtopics/mobility/midp/ttips/appsize/

Rule 4: Always_catch_OutOfMemoryError_while_allocating_large_arrays

Severity:  High
Rule:  Instead of letting the device's default mechanism report an OutOfMemoryError, the application should catch the error.
Reason:  Instead of letting the device's default mechanism report an OutOfMemoryError, the application should catch the error.

Usage Example: 

public class MyArrayAlloc
{
private final static int IMAGE_SIZE = 8*1024;

public static byte[] createNewImageMemory()
{
return new byte[IMAGE_SIZE]; // VIOLATION
}

}

Should be written as:

public class MyArrayAlloc
{
private final static int IMAGE_SIZE = 8*1024;

public static byte[] createNewImageMemory() 
{
try 
{
return new byte[IMAGE_SIZE];

catch (OutOfMemoryError error)  // CORRECTION
{
return new byte[0];
 
// Or report the error in an appropriate manner,
 // or use a different way of obtaining the memory
}
  }

}

Reference: 

Rule 5: Use_method_parameters_instead_of_returning_objects

Severity:  High
Rule:  Usually, the method creates a new object that might be quickly disposed, thus straining the memory resources of the device as well as the garbage collector.
Reason:  Usually, the method creates a new object that might be quickly disposed, thus straining the memory resources of the device as well as the garbage collector.

Usage Example: 

public class ReturnObjects
{

public static Dimension getDimensions(int x1, int y1, int x2, int y2) 
{
return new Dimension(Math.abs(x1-x2), Math.abs(y1-y2)); // VIOLATION
  }

}

Should be written as:

public class ReturnObjects
{

public static Dimension getDimensions(int x1, int y1, int x2, int y2,  Dimension  returnValue) 
{
returnValue.width = Math.abs(x1-x2);
returnValue.height = Math.abs(y1-y2);
return returnValue; // CORRECTION
 }

}

Reference: 

Rule 6: Avoid_overly_accessing_a_field

Severity:  High
Rule:  Eliminating excessive use of fields will bring down the code size and can potentially increase the execution speed.
Reason:  Eliminating excessive use of fields will bring down the code size and can potentially increase the execution speed.

Usage Example: 

public class HighAccess
{

private int value;

public void adjustValue(boolean a, boolean b, boolean c) 
{
if (a) 
{
  value += 1;
}
if (b) 
{
   value += 2;
}
if (c) 
{
value += 3;
}
if (a || b) 
{
  value += 4; // VIOLATION
}
  }

}

Should be written as:

public class HighAccess
{

private int value;

public void adjustValue(boolean a, boolean b, boolean c) 
{
int value = this.value; // CORRECTION
   if (a) 
{
  value += 1;
}
if (b) 
{
   value += 2;
}
if (c) 
{
value += 3;
}
if (a || b) 
{
  value += 4; 
}

this.value = value; // CORRECTION
  }

}

Reference:  http://developers.sun.com/techtopics/mobility/midp/articles/uidesign/

Rule 7: Avoid_large_number_of_constant_initializations_of_primitive_arrays

Severity:  High
Rule:  If large arrays need to be filled with predefined constants, this can cause a significant overhead in bytecode size.
Reason:  If large arrays need to be filled with predefined constants, this can cause a significant overhead in bytecode size.

Usage Example: 

public class ArrayInit
{
public void aMethod()
{
int[] prime = {2, 3, 5, 7, 11};  // VIOLATION
}
}

Should be written as:

Move large constant arrays into binary files and initialize the array from the content of the file.

Reference:  http://java.sun.com/developer/J2METechTips/2002/tt0226.html