How to Create An Immutable Class in java?

1. Immutable Class in Java

This is a common nterview question for 2-4 years java experienced developer. In this tutorial, We'll learn "How to Create Immutable Class in java?" You'll learn why we need to create Immutable class and what are the advantages and as well the disadvantages of it.

Immutable class means it cannot be modified once it is created. If any modification on an immutable object then the result will give another immutable object.

Builtin API immutable classes:

String, StringBuffer, and all wrapper classes, etc.

2. Advantages

Let us see the benefits of creating an immutable class in java.

A)    It provides thread safety and can be shared with other threads without any external synchronization in a concurrent environment.

B)    An immutable object simplifies development time and easier to share with several threads.

C)    Immutable object improves the performance by reducing synchronization code.

3. Disadvantages: 

Below are the disadvantages of creating immutable classes in the wrong scenarios.

A)    Sensitive data can be saved in memory like a password’s. better to use char[] array over the string.

B)    Immutable objects cannot be reused. Just use and throw. It's heavy for garbage collection.

4. Rules:

To create an immutable class in java, you have to do the following steps.

1. Declare the class as final so it can’t be extended.
2. Make all fields private so that direct access is not allowed.
3. Don’t provide setter methods for variables
4. Make all mutable fields final so that it values can be assigned only once.
5. Initialize all the fields via a constructor performing the deep copy.
6. Perform cloning of objects in the getter methods to return a copy rather than returning the actual object reference.

Even though, In String class hashcode() method is non – final and will return always unique value.

5. Java Program To Create Immutable class 

package com.java.w3schools.immutable.class;

final class StudentImmutableClass {
    private final int rollNo;
    private final String name;

    public StudentImmutableClass(int rollNo, String name) {
        this.rollNo = rollNo;
        this.name = name;
    }
    public int getRollNo() {
        return rollNo;
    }
    public String getName() {
        return name;
    }
}

Main Class:

public class ImmutableExample {
    public static void main(String[] args) {
        System.out.println("Creating Immutable object example in java");
        StudentImmutableClass student1 = new StudentImmutableClass(1, "adeepdrive");
        System.out.println("Immutable object student1 roll no : " + student1.getRollNo());
        System.out.println("Immutable object student1 name : " + student1.getRollNo());
    }
}

Output:

Creating Immutable object example in java
Immutable object student1 roll no : 1
Immutable object student1 name : 1

Here no chance to modify the student1 object. Because it has no setter methods and class is declared as final. So, subclasses as well can not modify them.

6. Instance members references to another class (Eg. Date):

In case, if Immutable class has the references to a Mutable class (java.util.Date). Despite storing the Date into the final variable, its internal values can be changed by the calling Date class methods such as set() method. So, we lost its original data.

It is advised to return a copy of the original object so that original date value can not be modified. If any modification is done to the returned Date object, those values do not modify the original Date object. Finally, we can preserve the immutability of class.

 public final class ImmutableReminder{
    private final Date remindingDate;
    public ImmutableReminder (Date remindingDate) {
        if(remindingDate.getTime() < System.currentTimeMillis()){
            throw new IllegalArgumentException("Can not set reminder" + " for past time: " + remindingDate);
        }
        this.remindingDate = new Date(remindingDate.getTime());
    }
    public Date getRemindingDate() {
        return (Date) remindingDate.clone();
    }
}

7. Conclusion

In this tutorial, We've seen the rules, advantages, and disadvantages of an immutable class.


And also seen how to create an immutable class?

What happens if an Immutable class has references to a Mutable class such as Date or StringBuffer etc.

Discussed all of these in detail in this post. If you like please share this article with friends.

8. Other References

These are the additional references used in this article.

String API

Official Ref

Reference