OBJ03-J. Be careful about final reference

When a variable is declared final, it is believed to be immutable. If the variable is a primitive type, it can undoubtedly be made final. If the variable is a reference to an object, however, what appears to be final may not always be.

Noncompliant Code Example

In this example, the values of a and b have been changed. When a reference is declared final, it only signifies that the reference cannot be changed, while the contents that it refers to can still be.

class FinalClass{
  FinalClass(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 a is: "+this.a);
    System.out.println("the value b is: "+this.b);
  }
  private int a;
  private int b;
}

public class FinalCaller {
  public static void main(String[] args) {
    final FinalClass fc = new FinalClass(1,2);
    fc.print_ab();
    //now we change the value of a,b.
    fc.set_ab(5, 6);
    fc.print_ab();
  }
}

Noncompliant Code Example

If a and b have to be kept immutable after their initialization, the simplest approach is to declare them as final.

void set_ab(int a, int b){ //But now compiler complains about set_ab method!
  this.a = a;
  this.b = b;
 }
 private final int a;
 private final int b;

Unfortunately, now one cannot have setter methods of a and b.

Compliant Solution

An alternative approach is to provide a clone method in the class. The clone method can be used to get a copy of the original object. Now one can do anything to this new object without affecting the original object.

class NewFinal implements Cloneable
{
 NewFinal(int a, int b){
  this.a = a;
  this.b = b;
 }
 void print_ab(){
  System.out.println("the value a is: "+this.a);
  System.out.println("the value b is: "+this.b);
 }
 void set_ab(int a, int b){
  this.a = a;
  this.b = b;
 }
 public NewFinal clone() throws CloneNotSupportedException{
  NewFinal cloned = (NewFinal) super.clone();
  return cloned;
 }
 private int a;
 private int b;
}

public class NewFinalCaller {
  public static void main(String[] args) {
    final NewFinal nf = new NewFinal(1,2);
    nf.print_ab();
    //get the copy of original object
    try {
          NewFinal nf2 = nf.clone();
           //now we change the value of a,b of the copy.
          nf2.set_ab(5, 6);
	   //but the original value will not be changed
	  nf.print_ab();
    } catch (CloneNotSupportedException e) { e.printStackTrace(); }
  }
}

Another common mistake is to use a public static final array. Clients can trivially modify the contents of the array (although they will not be able to change the array itself, as it is final).

Noncompliant Code Example

With this declaration, SOMETHINGS[1], etc. can be modified by clients of the code.

public static final SomeType [] SOMETHINGS = { ... };

Compliant Solution

One approach is to make use of the above method: first define a private array and then provide a public method that returns a copy of the array:

private static final SomeType [] SOMETHINGS = { ... };
public static final SomeType [] somethings() {
  return SOMETHINGS.clone();
}

Now the original array values cannot be modified by a client.

Compliant Solution

An alternative approach is to have a private array from which a public immutable list is constructed:

private static final SomeType [] THE_THINGS = { ... };
public static final List<SomeType> SOMETHINGS =
Collections.unmodifiableList(Arrays.asList(THE_THINGS));

Now neither the original array values nor the public list can be modified by any client.

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.

Related Vulnerabilities

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

References

Chapter 6, Core Javaâ„¢ 2 Volume I - Fundamentals, Seventh Edition by Cay S. Horstmann, Gary Cornell
Publisher:Prentice Hall PTR;Pub Date:August 17, 2004

OBJ02-J. Avoid using finalizers      06. Objects Orientation (OBJ)      OBJ31-J. Misusing public static variables