Introduction to Immutable Class in Java
In this article, we will explain the immutable class in java. Also, we will see the uses of immutable class. There will be java code examples showing how immutable class can be created in java. An immutable class is a class whose contents cannot be changed.
Following are some important points regarding the immutable class:
- Objects of an immutable class are called immutable objects. While dealing with immutable objects, we are not allowed to change an object’s state after its creation. Whenever the state of an object is changed, we get a new object.
- Immutable classes do not provide any methods for changing their content.
- In Immutable classes, only getter methods are available and not setter methods.
- Immutable classes are by default thread-safe in nature.
- Java legacy classes, wrapper classes, String class, are examples of immutable classes in java.
How to Use an Immutable Class in Java?
Before using this class, it is important to know how an immutable class is created. Following are important points to be kept in mind while creating the class:
- An immutable class must be final as it should not be inherited.
- All fields of an immutable class should be made final.
- If any mutable object is used as a field in an immutable class, then special handling has to be implemented so as to prevent its contents from being modified.
- A public constructor should be present.
- Getter methods for all the variables should be defined.
- Setter methods should not be present for any variables.
Following are the main uses of immutable classes in java:
- Simplicity: Since in the case of immutable class, each class is in a single state; therefore, it is a simple design pattern.
- Thread Safe: Another advantage of immutable class comes in the case of a multithreaded environment where no synchronization is required because of the thread-safe nature of the immutable class.
- Robust Design: Writing immutable classes in an application results in robust code.
Apart from the listed advantages, there can be some performance issues when using immutable classes. Hence where thread safety and other features are not important, we can consider using mutable classes for performance improvement.
Examples of Immutable Class in Java
Below are the examples mentioned:
Example #1 – Creating Immutable Class
Now we will see java code examples showing the creation of immutable classes in java. Here is a java code example showing how immutable classes are created in java:
Code:
package com.edubca.immutabledemo;
public final class ImmutableDemo {
final String studentName;
final int rollNumber;
public ImmutableDemo (String studentName, int rollNumber) {
this.studentName = studentName;
this.rollNumber = rollNumber;
}
public String getStudentName() {
return studentName;
}
public int getRollNumber() {
return rollNumber;
}
public static void main(String[] args) {
ImmutableDemo obj = new ImmutableDemo ("John" , 100);
// Since no getters are available contents cannot be modified.
// Also as variables are declared final they cannot be modified
System.out.println("Name is " + obj.getStudentName());
System.out.println("Roll Number is " + obj.getRollNumber());
}
}Output:
The above code shows the creation of an immutable class that does not contain any mutable object as a class member.
Example #2 – Immutable Class Example in Java
Now we will see how to create immutable classes having mutable objects as their members. Some special handling is required In order to maintain immutability in this case.
Problem with a Mutable Object in an Immutable Class:
Here is code example normal showing creation of immutable class having mutable members in it:
Code:
package com.edubca.immutabledemo;
import java.util.Date;
import java.text.SimpleDateFormat;
public final class ImmutableDemo {
final String studentName;
final int rollNumber;
final Date birthDate;
public ImmutableDemo (String studentName, int rollNumber, Date birthDate) {
this.studentName = studentName;
this.rollNumber = rollNumber;
this.birthDate=birthDate;
}
public String getStudentName() {
return studentName;
}
public int getRollNumber() {
return rollNumber;
}
public Date getBirthDate() {
return birthDate;
}
public static void main(String[] args) throws Exception {
String birthDate= "31/09/1997";
ImmutableDemo obj = new ImmutableDemo ("John" , 100, new SimpleDateFormat("dd/MM/yyyy").parse(birthDate));
System.out.println("Name is " + obj.getStudentName());
System.out.println("Roll Number is " + obj.getRollNumber());
System.out.println("Birth date is " + obj.getBirthDate());
obj.getBirthDate().setTime(1000);
System.out.println("After changing birth date>>>>>>>>>>>>");
System.out.println("Name is " + obj.getStudentName());
System.out.println("Roll Number is " + obj.getRollNumber());
System.out.println("Birth date is " + obj.getBirthDate());
}
}Output:
From the above output, we can see that the contents of the object are changed since the birth date is changed. This breaks the rules of the immutable class.
The Solution to the Problem with a Mutable Object in an Immutable Class:
In order to handle such cases, some changes need to be implemented in the code. In the modified code, when returning mutable objects from the getting method, we do not return the original object; rather, we return the clone of the object. Hence changes to cloned objects do not have any effect on the original object. Here is the modified code:
Code:
package com.edubca.immutabledemo;
import java.util.Date;
import java.text.SimpleDateFormat;
public final class ImmutableDemo {
final String studentName;
final int rollNumber;
final Date birthDate;
public ImmutableDemo (String studentName, int rollNumber, Date birthDate) {
this.studentName = studentName;
this.rollNumber = rollNumber;
this.birthDate=birthDate;
}
public String getStudentName() {
return studentName;
}
public int getRollNumber() {
return rollNumber;
}
public Date getBirthDate() {
return (Date)birthDate.clone();
}
public static void main(String[] args) throws Exception {
String birthDate= "31/09/1997";
ImmutableDemo obj = new ImmutableDemo ("John" , 100, new SimpleDateFormat("dd/MM/yyyy").parse(birthDate));
System.out.println("Name is " + obj.getStudentName());
System.out.println("Roll Number is " + obj.getRollNumber());
System.out.println("Birth date is " + obj.getBirthDate());
obj.getBirthDate().setTime(1000);
System.out.println("After changing birth date>>>>>>>>>>>>");
System.out.println("Name is " + obj.getStudentName());
System.out.println("Roll Number is " + obj.getRollNumber());
System.out.println("Birth date is " + obj.getBirthDate());
}
}Output:
From the above output, we can see no change in date value; hence, the class’s immutability remains intact.
Conclusion
From the above discussion, we have a clear understanding of java immutable classes. Also, we have seen the advantages of it.
Recommended Articles
This is a guide to Immutable Class in Java. Here we discuss the introduction and how to use an immutable class in java, along with examples and code implementation. You may also look at the following articles to learn more –
