Page History

This guideline has been deprecated.  It has been merged with:

• OBJ01-J. Limit accessibility of fields                

06/15/2015 -- Version 1.0

class Point {
  private int x;
  private int y;

  Point(int x, int y) {
    this.x = x;
    this.y = y;
  }
  void set_xy(int x, int y) {
    this.x = x;
    this.y = y;
  }
  void print_xy() {
    System

When you declare a variable *{_}final{_}*, you do not want anyone to change it.  If the type of variable is *{_}primitive types{_}*, you can undoubtedly make it. Unfortunately, if the variable is  a *{_}reference to an object{_}*, the "final" stuff you think may be not final\!

h2. Noncompliant Code Example

class Test{
 
 Test(int a, int b)
{   this.a = a;   this.b = b;  }
 void set_ab(int a, int b){  this.a = a;  this.b = b; }
 }
 void print_ab()
{   System.out.println("the value ax is: " + this.ax);
      SystemSystem.out.println("the value by is: " + this.by);  }
 private int a;
 private int b;
}}
}

public class TestFinal1PointCaller {
 
   public static void main(String\[\] args) {
{           final TestPoint mytestpoint = new TestPoint(1, 2);
           mytestpoint.print_abxy();

           //now we changeChange the value of a,b.         mytestx, y
    point.set_abxy(5, 6);
           mytestpoint.print_abxy();             }
We can see that the value of a and b has been changed, which means that when you declare a reference *{_}final{_}*, it only means that the reference can not be changed but the contents it refer to can still be changed\! 
\\

h2. Compliant Solution

If you do not want to change a and b after they are initialized, the simplest approach is to declare a and b *{_}final:_* private final int a;
 private final int b;
But now you can not have setter method of a and b.

h2. Compliant Solution 2

An alternative approach is to provide the *{_}clone{_}* method in the class. When you want do something about the object, you can use *{_}clone{_}* method to get a copy of original object. Now, you can do everything to this new object, and the original one will be never changed.  public Test2
  }
}

class Point {
  private final int x;
  private final int y;

  Point(int x, int y) {
    this.x = x;
    this.y = y;
  }
  void print_xy() {
    System.out.println("the value x is: " + this.x);
    System.out.println("the value y is: " + this.y);
  }

  // set_xy(int x, int y) no longer possible
}

final public class Point implements Cloneable {
  private int x;
  private int y;

  Point(int x, int y) {
    this.x = x;
    this.y = y;
  }
  void set_xy(int x, int y) {
    this.x = x;
    this.y = y;
  }
  void print_xy() {
    System.out.println("the value x is: "+ this.x);
    System.out.println("the value y is: "+ this.y);
  }
  public Point clone() throws CloneNotSupportedException{
{      Test2Point cloned = (Test2Point) super.clone();   return
    // No need to clone x and y as they are primitives
    return cloned;
   }
}\\

h2. Risk Assessment

Using final to declare the reference to an object is a potential security risk, because the contents of the object can still be changed. 
|| Recommendation || Severity || Likelihood || Remediation Cost || Priority || Level ||
| SEC37-J | medium | likely | low | {color:red}{*}P18{*}{color} | {color:red}{*}L1{*}{color} |

h2. Automated Detection

TODO

h2. Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

h2. References

Chapter 6, Core Java™ 2 Volume I - Fundamentals, Seventh Editionpublic class PointCaller {
  public static void main(String[] args) 
      throws CloneNotSupportedException {
    Point point = new Point(1, 2);    // Is not changed in main()
    point.print_xy();
    
    // Get the copy of original object
    Point pointCopy = point.clone();
    // pointCopy now holds a unique reference to the 
    // newly cloned Point instance

    // Change the value of x,y of the copy.
    pointCopy.set_xy(5, 6);

    // Original value remains unchanged
    point.print_xy();
  }
}