How to Create Immutable Objects in Java

In Java programming, creating immutable objects is quite important, particularly in multi-threaded applications where data consistency and thread safety are paramount. Immutable objects, once created, cannot be altered. This immutability can lead to simpler, more robust code that is easier to understand and maintain. In this blog post, we will explore the concept of immutability in Java, discuss its benefits, and will provide you the steps to create an immutable class.

What is Immutability?

Immutability refers to the state of an object remaining constant after its creation. Immutable objects do not allow any modification of their state once they are constructed. This is particularly useful in concurrent programming, as it eliminates issues related to data corruption or synchronization.

Benefits of Immutable Objects

1. Thread Safety: Immutable objects are naturally thread-safe since their state cannot change after construction, eliminating the need for synchronization. This makes it easier to share the object between multiple threads.
2. Cache-Friendly: The unchangeable nature of immutable objects makes them ideal candidates for caching, as their hash code remains constant.
3. Enhanced Security: Immutable objects provide secure data access, especially important in scenarios where data should not be altered once constructed.

Also read: How to configure JaCoCo for Code Coverage in Spring boot Applications

How to Create Immutable Objects in Java

Creating an immutable class in Java involves a few key principles and techniques:

1. Use final Class Modifier

Mark the class with the final keyword to prevent subclassing, which can potentially alter its immutable behavior.

public final class ContactInfo {
    ...
}

private final String name;
private final String email;

public ContactInfo(String name, String email) {
    this.name = name;
    this.email = email;
}

private final Date birthDate;

public ContactInfo(Date birthDate) {
    this.birthDate = new Date(birthDate.getTime()); // Create a new Date object
}

public Date getBirthDate() {
    return new Date(birthDate.getTime()); // Return a copy, not the real object
}

import java.util.Date;

public final class Employee {
    private final int id;
    private final String name;
    private final Date birthDate; // Using Date which is mutable and needs careful handling

    /**
     * Constructs an Employee instance with provided details.
     * Ensures the birthDate is handled immutably by creating a defensive copy.
     *
     * @param id the employee's ID
     * @param name the employee's name
     * @param birthDate the employee's birth date
     */
    public Employee(int id, String name, Date birthDate) {
        this.id = id;
        this.name = name;
        // Make a defensive copy of mutable objects to ensure the immutability of Employee
        this.birthDate = new Date(birthDate.getTime());
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    /**
     * Returns a defensive copy of the birthDate to ensure the caller cannot alter the internal state.
     * 
     * @return a new Date object representing the employee's birth date
     */
    public Date getBirthDate() {
        return new Date(this.birthDate.getTime());
    }
}