Advantages of Immutable Classes in Java

In Java, the immutable class can be defined such that when the object of it is created, it's content cannot be changed again. All the wrapper classes in Java such as Integer, Boolean, Byte, Short are immutable.

In Java, immutable classes are known for providing various benefits which are utilized in designing better code, performance, and safety. Let's understand few benefits of immutable classes in Java in detail.

Safety of Thread: The objects of immutable classes are known to be thread-safe as the state of these objects cannot be altered or changed after their creation. In an environment related to multi-threading, the needs for mechanisms of synchronization will be eliminated.
Easier Maintenance: The code becomes more predictable because of utilization of immutable classes. As we discussed earlier that the state of an object of immutable class cannot be modified or changed, the worry for occurrence of unexpected changes in the code will be eliminated. Because of immutable classes, debugging and maintenance are made easy.
Caching: The objects of the immutable classes can be reused and cached because their state remains same no matter what. The improvement in the performance can be achieved by reducing the necessity for creation of new objects.
Security: The security can be enhanced with the help of immutability as it can be utilized for preventing unintended or malicious changes or modification of the state of an object. This is considered important when working on data of high sensitivity and when the data integrity is a priority.
Promotes Functional Programming: The principles of functional programming align well with the objects of the immutable classes. Writing pure functions is made easy because of immutable objects where the output is purely dependent on the input without any other effects.
Copy Mechanism: In an object of immutable class when any change is required, a new object will be created with the specific modifications. This makes the way for a copy mechanism which can be utilized for creating modified versions of objects without changing or editing the original versions. In situations when the different versions of an object or the history of changes needs to be maintained, this will be useful.
Guaranteed Initialization: As we know that the state of an object of immutable class is declared at the time of its creation, it is clear that the instance of the class must always be initialized properly. The bugs related to non-initialized state can be avoided using this.

Let's understand in detail about the features and functionalities of Immutable classes with the help of an example Java program.

Example 1:

Filename: ImmutableClass.java

// Java program for demonstrating the features and functionalities of Immutable classes in Java along with its advantages.
// The Immutable Class.
final class Location {
    private final String Town;
    private final String State;
    // Constructor of the above-mentoined class.
    public Location(String Town, String State) {
        this.Town = Town;
        this.State = State;
    }
    // Getter methods for assigning values to final variables.
    public String getCity() {
        return Town;
    }
    public String getState() {
        return State;
    }
    // Representing the String variable as an Object type.
    @Override
    public String toString() {
        return "Location{Town='" + Town + "', State='" + State + "'}";
    }
}
// Another Immutable class.
final class Employee {
    private final String emp_Name;
    private final int emp_Age;
    private final Location emp_Address;
    // Constructor of the above-mentoined class.
    public Employee(String emp_Name, int emp_Age, Location emp_Address) {
        this.emp_Name = emp_Name;
        this.emp_Age = emp_Age;
        // Creation of defensive copy for ensuring immutability.
        this.emp_Address = new Location(emp_Address.getCity(), emp_Address.getState());
    }
    // Getter Methods for Setting the Values of final variables.
    public String getName() {
        return emp_Name;
    }
    public int getAge() {
        return emp_Age;
    }
    public Location getAddress() {
        // Returning a defensive copy to ensure Location is also immutable
        return new Location(emp_Address.getCity(), emp_Address.getState());
    }
    // Representing String variable as an Object.
    @Override
    public String toString() {
        return "Employee{Name='" + emp_Name + "', Age=" + emp_Age + ", Address=" + emp_Address + '}';
    }
}
public class ImmutableClass {
    public static void main(String[] args) {
        // Creation of an Immutable Object.
        Location emp_Address = new Location("Hyderabad", "Telangana");
        Employee person = new Employee("Eshwar", 21, emp_Address);
        // Prints the initial state.
        System.out.println("Employee: " + person);
        // Creation of another Immutable Object with different values.
        Location new_Address = new Location("Siddepet", "Telangana");
        // Create a new Employee object with updated values
        Employee updatedPerson = new Employee("Sreeram", 21, new_Address);
        // Prints the updated state
        System.out.println("Updated Employee: " + updatedPerson);
        // Demonstrating immutability without any setters.
        // Demonstrate immutability of the Location variable object of Employee
    }
}

Output:

Employee: Employee{Name='Eshwar', Age=21, Address=Location{Town='Hyderabad', State='Telangana'}}
Updated Employee: Employee{Name='Sreeram', Age=21, Address=Location{Town='Siddepet', State='Telangana'}}

Next TopicBMI Calculator Java

← prev next →