Create Immutable Class in Java

In Java, creating immutable classes is a fundamental best practice for ensuring object immutability. Immutable objects are objects whose state cannot change after creation. They provide simplicity, thread safety, and are widely used in Java class design. In this article, we'll explore what an immutable class is, its advantages, and how to create one in Java using best practices.

What is an Immutable Class in Java?

An immutable class in Java is a class whose objects cannot be modified after their creation. All modifications require creating a new object. A popular example of an immutable class is the String class in Java.

Characteristics of an Immutable Class

• The class must be declared as final to prevent subclassing.
• All fields of the class should be declared private and final.
• No setter methods should be provided for modifying the fields.
• Any mutable fields must be deeply cloned during construction and access.

Steps to Create an Immutable Class in Java

Follow these steps to create an immutable class:

1. Declare the Class as final

Marking the class as final ensures it cannot be subclassed, preventing unintended behavior through overriding.

2. Make Fields private and final

Declaring fields as private and final ensures their values cannot be changed after initialization.

3. Initialize Fields Using a Constructor

Use a constructor to initialize the fields of the class. Ensure mutable fields are deeply copied if they exist.

4. Avoid Setter Methods

Do not provide setters or methods that can modify the object's state.

5. Implement Deep Copy for Mutable Fields

If the class contains references to mutable objects, clone or create a copy of those objects to avoid external modifications.

Example of an Immutable Class in Java

Here’s an example of an immutable class:

final class ImmutableClass {
    private final String name;
    private final int age;
    private final Address address; // Mutable field

    public ImmutableClass(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = new Address(address); // Deep copy of mutable object
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Address getAddress() {
        return new Address(address); // Return deep copy
    }
}

class Address {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public Address(Address address) {
        this.city = address.city;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

Advantages of Immutable Classes

Using immutable objects in Java has several benefits:

• Thread Safety: Immutable objects are inherently thread-safe as their state cannot change.
• Simplicity: Easier to design and maintain.
• Better Performance: Immutable objects can be cached and reused.
• Safe Sharing: Multiple references can safely share an immutable object without the risk of unintended changes.

When to Use Immutable Classes

Immutable classes are ideal in the following scenarios:

• When working with multithreaded applications.
• When designing classes for caching or safe sharing of objects.
• When implementing key classes in Java class design such as database records, configurations, or constants.

FAQs

1. Why are immutable classes used in Java?

Immutable classes provide thread safety, simplicity, and reliability by ensuring that their state remains constant throughout their lifecycle. They are commonly used in multithreaded environments.

2. How does immutability improve Java memory management?

Immutable objects can be safely cached and reused, reducing the need for creating multiple instances and improving memory efficiency.

3. Can an immutable class contain mutable fields?

Yes, but mutable fields should be deeply cloned during construction and access to prevent external modifications.

4. How is immutability different from final in Java?

Immutability ensures that the object’s state cannot change after creation, whereas the final keyword prevents reassigning a variable or subclassing a class.

5. Is String the only immutable class in Java?

No, other immutable classes include Integer, Boolean, Big Decimal , and Big Integer .

Conclusion

Creating an immutable class in Java is a key best practice in Java class design. Immutable objects ensure stability, thread safety, and efficient memory management. By following the steps outlined in this guide, you can design robust and reliable classes for various applications.