How to Create an Immutable Class in Java

In Java, an immutable class is one whose objects cannot be modified after they are created. Once an object of an immutable class is instantiated, its state (i.e., the values of its fields) cannot be changed. This property is beneficial in multi-threaded environments, as immutable objects are inherently thread-safe, meaning multiple threads can access them concurrently without any issues related to data inconsistency.

In this blog post, we will explore how to create an immutable class in Java, its advantages, and some important considerations when designing immutable objects.

Why Use Immutable Classes?

Immutable classes offer several advantages in Java programming:

1. Thread-Safety: Since immutable objects cannot be changed, they can be safely shared between multiple threads without the need for synchronization.
2. Simpler Code: Immutable objects are often easier to reason about because their state never changes once created.
3. HashCode Consistency: Immutable objects are safe to use as keys in hash-based collections (e.g., HashMap, HashSet) because their hash code will remain constant during their lifetime.
4. Security: Immutable objects are more secure because their internal state cannot be tampered with, which helps avoid unexpected changes.

How to Create an Immutable Class

Creating an immutable class in Java involves a few simple steps. Let’s walk through them.

1. Make the Class final

The first step in creating an immutable class is to mark the class as final. This prevents subclassing, which could potentially modify its behavior.

public final class Person {
    // Fields and constructor will be added here
}

2. Make Fields private and final

To ensure that the fields of the class are not directly accessible or modifiable, make them private and final. The final keyword ensures that the reference to the object cannot be reassigned once initialized.

public final class Person {
    private final String name;
    private final int age;
}

3. Provide a Constructor to Initialize Fields

Provide a constructor that initializes all fields. This constructor will be the only place where the fields are set. Once initialized, the fields cannot be modified.

public final class Person {
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

4. Do Not Provide Setter Methods

Since an immutable object’s fields cannot change after construction, do not provide setter methods. This ensures that the fields cannot be modified after the object is created.

// No setters allowed for immutable fields
// public void setName(String name) { this.name = name; }

5. Return a Copy of Mutable Objects (if applicable)

If your immutable class contains any mutable fields (e.g., arrays, lists, or custom objects), make sure to provide deep copies of those objects in the constructor and getter methods. This prevents the external modification of the object’s internal state.

Example with a mutable object (like a Date object):

import java.util.Date;

public final class Person {
    private final String name;
    private final int age;
    private final Date birthDate;

    public Person(String name, int age, Date birthDate) {
        this.name = name;
        this.age = age;
        // Deep copy of mutable field
        this.birthDate = new Date(birthDate.getTime());
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Date getBirthDate() {
        // Return a copy to maintain immutability
        return new Date(birthDate.getTime());
    }
}

Here, the Date object is mutable, so we create a copy of it in the constructor. The getter also returns a new instance of the Date object, ensuring that external code cannot modify the internal birthDate field.

6. Override equals() and hashCode() Methods

For consistency, it’s a good idea to override the equals() and hashCode() methods in an immutable class. This is especially important if the class will be used as a key in hash-based collections like HashMap.

Here’s an example of how to override these methods:

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null || getClass() != obj.getClass()) return false;
    Person person = (Person) obj;
    return age == person.age && name.equals(person.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

7. Override toString() Method (Optional)

It is also a good practice to override the toString() method to provide a meaningful string representation of the object.

@Override
public String toString() {
    return "Person{name='" + name + "', age=" + age + ", birthDate=" + birthDate + "}";
}

Complete Example of an Immutable Class

Here’s the final implementation of an immutable class, Person, that demonstrates all the steps discussed above:

import java.util.Date;
import java.util.Objects;

public final class Person {
    private final String name;
    private final int age;
    private final Date birthDate;

    // Constructor to initialize fields
    public Person(String name, int age, Date birthDate) {
        this.name = name;
        this.age = age;
        // Creating a deep copy of the mutable field
        this.birthDate = new Date(birthDate.getTime());
    }

    // Getter methods
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Date getBirthDate() {
        return new Date(birthDate.getTime()); // Return a copy of birthDate
    }

    // Override equals and hashCode for consistent comparisons
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    // Override toString for a meaningful representation
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", birthDate=" + birthDate + "}";
    }
}

Using the Immutable Class

Here’s how you can create and use instances of the Person class:

import java.util.Date;

public class Main {
    public static void main(String[] args) {
        // Creating an immutable object
        Date birthDate = new Date();
        Person person = new Person("John Doe", 30, birthDate);

        // Accessing fields through getter methods
        System.out.println(person.getName()); // Output: John Doe
        System.out.println(person.getAge());  // Output: 30
        System.out.println(person.getBirthDate()); // Output: Current date and time

        // Modifying the original birthDate object will not affect the immutable person object
        birthDate.setTime(0);
        System.out.println(person.getBirthDate()); // Output: Original birthDate, unaffected by modification
    }
}

Conclusion

Creating an immutable class in Java is a great way to ensure that objects remain constant and thread-safe once they are created. By making the class final, making fields private and final, and preventing setters, we can ensure that the object’s state cannot be modified.

Additionally, when dealing with mutable objects, remember to create deep copies to maintain immutability and protect the object’s internal state. Immutable classes are especially useful in concurrent programming, functional programming paradigms, and when working with data that should not change after initialization.