Question

This is a strange one, am wondering if this is by design or a compiler bug. Am using Sun Java 6 on a PC, but also seen with Sun Java 5 on a linux box.

Suppose I have a file on disk containing a serialized class. I then add a final field to the class and declare and initialize the field in one statement:

public final int newField = 2;

If I read in an object that was serialized before this field was added, this new field is given a default value of 0, which is correct. However, the compiler replaces occurrences of the field by the constant “2”. OTOH, if I instead initialize the new field inside of a constructor:

Data (int d) {
    this.oldField = d;
    this.newField = 2;
}

then the field does not get optimized away and everything works as expected.

More explicitly, here is my Main class:

import java.io.*;
public class Main {
    public static void main(String[] args) {
        try {       
            FileInputStream fis = new FileInputStream ("Data.txt");
            ObjectInputStream ois = new ObjectInputStream (fis);

            Data d = (Data)ois.readObject();
            ois.close();
            fis.close();

            d.print();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}

and here is the Data class:

import java.io.*;
public class Data implements Serializable {
    private static final long serialVersionUID = 1;
    private int oldField;
    private final int newField = 2;

    Data(int d) {
        this.oldField= d;
    }

    public void print() {        {
        System.out.println(this.oldField + " " + this.newField);
    }
}

So my Data.txt file has a serialized instance of the original class with just “oldField = 1”. So the expected output of running this is

1 0

but instead I get

1 2

whereas if I move the initialization into the constructor the output is correct.

Is this expected behaviour? My feeling is that the compiler should not be optimizing away fields in serialized classes, precisely for this reason. Perhaps that is asking too much. Thanks!

Answer 1

This is by design. If a variable is declared as final, has a primitive type and an initializer which is a constant expressions, then it is a “constant variable”. This alters the semantics of initialization among other things. Specifically, the expression value is evaluated at compile time, and then embedded into the code.

Refer to JLS 4.12.4 for details.

When you put the initialization into the constructor, the variable is no longer a “constant variable” and normal initialization occurs.

---

By the way, I would have thought that a final variable having a different value than what the initializer said was a bad thing, not a good thing. To me, that would be highly unintuitive. At any rate, relying on this kind of behaviour does not strike me as good practice.