How to create immutable class in Java

Last Updated: 20 April, 2023

In the tutorial, we are going to discuss what immutable objects are and how to create a custom immutable class in Java.

In Java, an immutable object is one whose state cannot be changed once it has been created. The state of such an object can be changed by creating a new copy with the intended changes. Immutable classes are useful for representing values that should not be changed after they are initialized.

📝 Java has provided many built-in immutable classes, such as String, wrapper classes (Integer, Long, Float, etc.), BigInteger, BigDecimal, Locale, etc.

To create an immutable class in Java, we should follow these steps:

Declare the class as final so no other class can extend it.

All data members in the class must be declared private so that they cannot be accessed directly outside of the class.

All the data members in the class must be declared as final, so no one can change the value after object creation.

A parameterized constructor should perform a deep copy on all fields so that data members cannot be modified with an object reference.

Write only getter methods inside the class, and getter methods should return a copy of objects instead of the actual object reference as a result of performing deep copies.

Do not provide setter methods in the class because setter methods can change an object’s state.

Let's understand the custom immutable class with the help of the given example below.

Java Custom Immutable Class Example

    
    // Declare class as final
    final class Student {
      // Declare data-members as private and final
      private String studentName;
      private String className;
      private int rollNo;
      
      // Parameterized constructor
      public Student(String studentName, String className, int rollNo) {
        // class members are initialized using constructor
        this.studentName = studentName;
        this.className = className;
        this.rollNo = rollNo;
      }
      
      // Getter methods to access data outside the class
      // But, No setter methods are allowed
      public String getStudentName() {
        return studentName;
      }
      
      public String getClassName() {
        return className;
      }
      
      public int getRollNo() {
        return rollNo;
      }
    }
    
    public class ImmutableExample {
      public static void main(String[] args) {
        
        // create object of Immutable class Student
        Student stuObject = new Student("Shreyansh Shanu", "Nursery", 11);
        
        System.out.println("Student Name: " + stuObject.getStudentName());
        System.out.println("Student Class: " + stuObject.getClassName());
        System.out.println("Student Roll No.: " + stuObject.getRollNo());
      }
    }

Output

Student Name: Shreyansh Shanu
Student Class: Nursery
Student Roll No.: 11

Use of Immutable class in Java

Due to the fact that they cannot change state, immutable objects are particularly useful for concurrent applications. This is because they cannot be corrupted or observed in an inconsistent state due to thread interference.