How is final reference variable is handled?

[Ankush Kanungo]

I understand that for final primitive types one can not change the value and for final reference variable, one can not change the reference, but can change the state of the object. I also understand that final primitive types are compile type constant, means they are replaced by their value at compile time.

My question is how the final reference variable are allowed to change their state? If they are compile constant, then how one can change the value at run time?

May be I am not able to frame the question properly.

Any help would be highly appreciated.

Thank you

[Mohamed Sanaulla]

Final references cannot be changed to point to a different instance. But you can do a- finalReferenceVariable.setSomeValue and change the value of some instance variable of that instance. They are constants because they cannot be made to point to a new instance or a different instance but changing the state doesnt mean the reference variable changes.

[Mittal Vishal]

When reference which is constant (final) points to an object, then it means it is pointing to a Heap Space where the object was created.
Final means reference cannot point to some other memory space, but the instance variable residing at that space can be changed.

[Campbell Ritchie]

mittal vishal wrote: . . . Final means reference cannot point to some other memory space, but the instance variable residing at that space can be changed.

That is confusing. What does it mean?

[Paul Clapham]

Ankush Kanungo wrote:My question is how the final reference variable are allowed to change their state?

That's correct, you have not framed the question properly.

A variable does not have a "state". A variable contains a reference to an object, and it's the object which has a "state". Don't confuse a variable with an object which it refers to. (This is a common point of confusion.)

So when you declare a variable "final", that means that you assign it a reference to an object at that point. You can never assign any other reference to that variable.

However you can certainly change the state of that object. There is no way for the JVM to determine whether there are any final variables referring to the object, anyway.

[Mittal Vishal]

Campbell Ritchie wrote:

mittal vishal wrote: . . . Final means reference cannot point to some other memory space, but the instance variable residing at that space can be changed.

That is confusing. What does it mean?

Every reference point to a memory space in heap. When any object is created, it is created on heap & the reference points to that memory space.
Step1) Object obj1 = new Object();
It means new objects is created on heap at some memory space. obj1 is pointing to that memory space
Now, if it is not declared as final then
Step2) Object obj2 = new Object();
Step3) obj1 =obj2; is a valid statement i.e. obj1 is now pointing to memory space where obj2 is pointing

but this is not a valid statement if obj1 was declared as final i.e. it is not allowed to point to some other memory space if it has already assigned a memory space.
In our case at step 1 it is pointing to a memory space so after that it cannot point to some other place

[Ankush Kanungo]

Thank you every one for their reply.

After doing some research and writing some sample code. It seems that Java uses some mechanism which does not allow final object to point to some other object at compile time. People who are saying about heap and all, I think, it all happens at runtime, if you have declared a reference to an object and trying to change the reference, the code will not even compile.

Please correct me if I am wrong.

Thank you

public class FinalPratice {
public static void main(String[] args) {
	final Student finalStudent = new Student();
	finalStudent.firstName = "Peter"; //allows to change the state of final object.
	finalStudent = new Student(); //compile time error, can not change reference.
	finalStudent.firstName = "John";
	}
}

class Student{
	String firstName;
}

[Campbell Ritchie]

Thank you for explaining what you meant, Mittal Vishal. I think final variables and fields are handled at compile-time. You can test this by compiling a little class like this

public class Foo
{
   private final int i = 123;
   private final String s = "Campbell";
}

Compile and display the bytecode like this

[campbell@campbell1110 java]$ gedit Foo.java
[campbell@campbell1110 java]$ javac Foo.java
[campbell@campbell1110 java]$ javap -c Foo

. . . and see whether there is any difference in the bytecode if you omit the two final keywords.

[Ankush Kanungo]

Campbell,

You are absolutely right. Final variables are compile time constant, i.e. their values are finalized at compile time and if you change the value, you need to again compiler all the classes where ever it is used in order to see the changed value. After doing some research, enums are an alternative to using final, because they get their value at run time.

Thank you all for their replies!!

[Mike Simmons]

Mmmm, some final variables are compile-time constants. Definitely not all of them are, however. In order to be a compile-time constant, a variable must be final, and the type of the variable must be a primitive or String, and the variable must be initialized at declaration using an expression which is itself a compile-time constant expression. The rules for what is a constant expression are somewhat longer - see them here.

For example, the following are not compile-time constants:

int x = 123;  // not final
final Integer y = 456;  // Integer is not primitive or String
final int z = Integer.parseInt("789"); // method call to parseInt() is not a constant expression