final vs Immutability in Java - GeeksforGeeks

02 Mar, 2022
final: In Java, final is a modifier that is used for class, method, and variable also. When a variable is declared with the final keyword, its value can’t be modified, essentially, a constant. Immutability: In simple terms, immutability means unchanging overtime or being unable to be changed. In Java, we know that String objects are immutable means we can’t change anything to the existing String objects.
Differences between final and immutability
final means that you can’t change the object’s reference to point to another reference or another object, but you can still mutate its state (using setter methods e.g). Whereas immutable means that the object’s actual value can’t be changed, but you can change its reference to another one.
final modifier is applicable for variable but not for objects, Whereas immutability applicable for an object but not for variables.
By declaring a reference variable as final, we won’t get any immutability nature, Even though reference variable is final. We can perform any type of change in the corresponding Object. But we can’t perform reassignment for that variable.
final ensures that the address of the object remains the same whereas the Immutable suggests that we can’t change the state of the object once created. 
JAVA
// Java program to illustrate// difference between final// and immutability class Geeks {    public static void main(String[] args)    {        final StringBuffer sb = new StringBuffer("Hello");         // Even though reference variable sb is final        // We can perform any changes        sb.append("GFG");         System.out.println(sb);         // Here we will get Compile time error        // Because reassignment is not possible for final variable        sb = new StringBuffer("Hello World");         System.out.println(sb);    }}
Output: 
Geeks.java:14: error: cannot assign a value to final variable sb
        sb = new StringBuffer("Hello World");
        ^
1 error
Pictorial Representation of the above Program
Explanation: In the above picture, we can see that we are creating an object of StringBuffer class by making reference final.
Declaring reference variable as final, does not mean that the object is immutable.
In the next line we are performing append() operation on the created object and it is successfully changed.
If the object is immutable, then the above append operation can’t be done.
But it is executed successfully as we declare the reference variable as final. final means we can’t reassign anything to that reference variable again.
Therefore when we try to create a new object of StringBuffer then it won’t create an object by throwing an error to the console.
vedprksh79
adnanirshad158
sachithsenarathnes
final keyword
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Functional Interfaces in Java
Stream In Java
Constructors in Java
Different ways of Reading a text file in Java
Exceptions in Java
Generics in Java
Comparator Interface in Java with Examples
Strings in Java
Difference between Abstract Class and Interface in Java
How to remove an element from ArrayList in Java?