The ultimate variable manipulation in Java

Question

Can someone please tell me what the following line means in the context of Java:

the final variable can still be manipulated if it is not immutable

As far as I know, declaring a variable to be final, you cannot change it again, and then what do the words immutable in the line above mean?

Answer 1

This means that if your final variable is a reference type (i.e. not primitive like int), then this is just a reference that cannot be changed. You cannot reference another object, but the fields of the object to which it relates can still be changed if the class allows it. For example:

final StringBuffer s = new StringBuffer(); 

The contents of a StringBuffer can still be changed arbitrarily:

 s.append("something"); 

But you cannot say:

 s = null; 

or

 s = anotherBuffer; 

On the other hand:

 final String s = ""; 

Strings are immutable - there simply is no method that would allow you to modify String (unless you use Reflection - and go to hell).

Answer 2

If you have a final reference to a Java object, you can still manipulate it, but you cannot change its reference. For example, this code is completely legal:

 import javax.swing.JLabel; class Test1 { private final static JLabel l = new JLabel("Old text"); public static void main(String[] args) { System.err.println(l.getText()); l.setText("New Text"); System.err.println(l.getText()); } } 

But you cannot say:

 l = new JLabel("Newest Text"); 

After the first assignment l. Please note that you can do this though:

 import javax.swing.JLabel; class Test1 { public static void main(String[] args) { final JLabel l; String s = getArbitaryString(); // Assume this method returns a string l = new JLabel(s); System.err.println(l.getText()); } } 

This can be done because when l is declared, it is not assigned to anything not even null. Thus, you are allowed to assign him something only once.

The same goes for primitives. You can assign it a value as follows:

 class Test1 { public static void main(String[] args) { final int i; i = 2; } } 

But now you cannot manipulate it further, because the only thing you can do for primitive types is to assign values ​​to them.

Answer 3

You cannot change which object or value the final variable belongs to. You can only assign the final variable once.

This does not affect the change in state of the object. The object itself can still be manipulated if it is not encoded in such a way that this manipulation is prohibited. An immutable object is an object whose state cannot change.

Answer 4

As others have said, this means that you can manipulate the object that the variable points to, but you cannot change the link (i.e. assign another object to the variable).

Objects that change in design, such as List , can be changed (you can add elements to them), whereas if you have an immutable object, such as String or Integer , you cannot change it (all operations supported by the class String , return a new instance and do not modify the actual object).

Answer 5

You can call any method on it, even if the method can change the state of the object referenced by. for example

 final MyClass myClass = new MyClass(); myClass.setVar(something); 

This is great because myClass itself myClass not change, i.e. you do not execute myClass = myClass1; .

Answer 6

The one that always kills me?

If you want the final variables to be really as safe as you thought, you need a lot of extra code to return a copy of the string [].

Answer 7

You can manipulate mutable final variables, for example. of type StringBuffer, but you cannot manipulate the final variables of immutable types.

In the case of mutable variables, a new object is not created each time the value changes. But in the case of immutable types, when you change the value, a new object is created, so when you make it final, you cannot change it.

Answer 8

Yes, the final variable can be changed.

  final StringBuffer s = new StringBuffer(); // won't work s = new StringBuffer(); //this works s.append("hai"); 

You cannot change the link, but you can change the fields of the object. for more details

Answer 9

You can still change the "final" variable using Reflection.