Immutable Class with Mutable Object in Java

In the realm of object-oriented programming, immutability is a powerful concept that enhances code robustness, thread safety, and overall program stability. An immutable class is one whose instances cannot be modified after creation. While immutability brings numerous advantages, there are scenarios where we need to handle mutable objects within immutable classes in Java. It delicate balance allows developers to design flexible and efficient systems without compromising the benefits of immutability.

Immutability

Immutability is achieved by making the fields of a class final and initializing them either through the constructor or at the time of declaration. Once the object is created, its state cannot be altered, ensuring thread safety and simplifying reasoning about code behavior. Immutable classes are often preferred for their ease of use in concurrent programming and the prevention of unintended side effects.

Challenges of Mutable Objects in Immutability

In certain situations, however, using immutable classes exclusively may not be practical. Consider scenarios where a particular field of an object needs to be mutable for performance reasons, or when interfacing with external systems that require state modification. In such cases, incorporating mutable objects within an otherwise immutable class becomes a necessity.

Strategies for Handling Mutable Objects in Immutable Classes

Defensive Copying

One common strategy is to create defensive copies of mutable objects during construction. It ensures that the internal state of the immutable class remains unchanged even if the original mutable object is modified elsewhere. The approach maintains the benefits of immutability while allowing controlled manipulation of the mutable object.

public class ImmutableClassWithMutableObject {
    private final List<String> mutableList;
    public ImmutableClassWithMutableObject(List<String> mutableList) {
        this.mutableList = new ArrayList<>(mutableList);
    }
    public List<String> getMutableList() {
        return Collections.unmodifiableList(mutableList);
    }
}

Wrapper Classes

Another approach is to use wrapper classes that encapsulate the mutable object and provide controlled access to its methods. This way, modifications to the internal state can be managed within the immutable class itself.

ImmutableClassWithMutableObject.java

public class ImmutableClassWithMutableObject {
    private final MutableObjectWrapper mutableObject;
    public ImmutableClassWithMutableObject(MutableObjectWrapper mutableObject) {
        this.mutableObject = new MutableObjectWrapper(mutableObject);
    }
    public MutableObjectWrapper getMutableObject() {
        return new MutableObjectWrapper(mutableObject);
    }
}
public class MutableObjectWrapper {
    private final List<String> mutableList;
    public MutableObjectWrapper(List<String> mutableList) {
        this.mutableList = new ArrayList<>(mutableList);
    }
    public void addElement(String element) {
        mutableList.add(element);
    }
    // Other methods to modify the internal state
}

Let's delve deeper into some considerations and best practices when dealing with immutable classes and mutable objects in Java.

1. Thread Safety and Immutability

One of the primary benefits of immutability is enhanced thread safety. Immutable objects can be safely shared among multiple threads without the need for locks. When incorporating mutable objects within an immutable class, ensure that the mutable state is properly encapsulated or synchronized to maintain thread safety.

2. Effective Defensive Copying

When creating defensive copies, it's essential to consider the depth of the copy. If the mutable object contains references to other mutable objects, a deep copy may be necessary to prevent unintended modifications. Additionally, carefully choose the appropriate collection classes for defensive copying based on the use case.

3. Immutable Collections

Java provides immutable collections in the Collections class, such as unmodifiableList, unmodifiableSet, and unmodifiableMap. These can be used to wrap mutable collections and provide an immutable view. However, be cautious, as these wrappers don't prevent modifications to the original collection.

List<String> mutableList = new ArrayList<>();
List<String> immutableList = Collections.unmodifiableList(mutableList);

4. Builder Pattern for Mutable Initialization

If constructing an object with multiple fields, some of which are mutable, consider using the Builder pattern. The builder can handle the mutable state during the construction phase, ensuring that the final object is immutable.

public class ImmutableClassWithMutableObject {
    private final List<String> mutableList;
    private ImmutableClassWithMutableObject(Builder builder) {
        this.mutableList = new ArrayList<>(builder.mutableList);
    }
    public static class Builder {
        private final List<String> mutableList = new ArrayList<>();
        public Builder addElement(String element) {
            this.mutableList.add(element);
            return this;
        }
        public ImmutableClassWithMutableObject build() {
            return new ImmutableClassWithMutableObject(this);
        }
    }
}
ImmutableClassWithMutableObject obj = new ImmutableClassWithMutableObject.Builder()
                                        .addElement("item1")
                                        .addElement("item2")
                                        .build();

5. Documentation and Contracts

Clearly document the immutability contract for the class, especially when mutable objects are involved. Make it explicit whether modifications to the mutable object will affect the state of the containing immutable class. Providing such information helps users of the class make informed decisions.

6. Consistency in Naming

Maintain a consistent naming convention for methods related to mutable objects. For example, if we choose to name a method for obtaining a mutable object getMutableObject(), be consistent across the codebase.

7. Testing for Immutability

Include tests to ensure the immutability of class, especially when mutable objects are involved. Test scenarios where the internal state remains unaltered despite external modifications to the mutable object.

By carefully considering these aspects and applying best practices, developers can create robust and flexible systems that harness the benefits of both immutability and controlled mutability when dealing with mutable objects in Java.

Let's create a simple example to demonstrate an immutable class with a mutable object in Java. In this example, we will use an immutable class to represent a student, and the mutable object will be a list of courses that the student is enrolled in.

File Name: ImmutableStudent.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ImmutableStudent {
    private final String name;
    private final List<String> enrolledCourses;
    public ImmutableStudent(String name, List<String> enrolledCourses) {
        this.name = name;
        // Create a defensive copy to ensure immutability
        this.enrolledCourses = new ArrayList<>(enrolledCourses);
    }
    public String getName() {
        return name;
    }
    // Return an unmodifiable view of the enrolled courses to maintain immutability
    public List<String> getEnrolledCourses() {
        return Collections.unmodifiableList(enrolledCourses);
    }
    public static void main(String[] args) {
        // Create a list of courses
        List<String> courses = new ArrayList<>();
        courses.add("Mathematics");
        courses.add("Physics");
        // Create an immutable student object
        ImmutableStudent student = new ImmutableStudent("John Doe", courses);
        // Display student information
        System.out.println("Student Name: " + student.getName());
        System.out.println("Enrolled Courses: " + student.getEnrolledCourses());
        // Attempt to modify the original list of courses
        courses.add("Computer Science");
        // Display student information again to show immutability
        System.out.println("\nAfter modifying the original list:");
        System.out.println("Student Name: " + student.getName());
        System.out.println("Enrolled Courses: " + student.getEnrolledCourses());
    }
}

Output:

Student Name: John Doe
Enrolled Courses: [Mathematics, Physics]
After modifying the original list:
Student Name: John Doe
Enrolled Courses: [Mathematics, Physics]

In this example, the ImmutableStudent class ensures immutability by creating a defensive copy of the list of enrolled courses during construction. The getEnrolledCourses() method returns an unmodifiable view of the list, preventing external modifications. The main() method demonstrates that even if the original list of courses is modified after the student object is created, the state of the student object remains unchanged.

Conclusion

While immutability is a powerful concept, there are scenarios where incorporating mutable objects within immutable classes is necessary. By employing strategies like defensive copying or using wrapper classes, developers can strike a balance between immutability and the need for mutable state. Careful consideration and thoughtful design are essential to ensure that the advantages of immutability are maintained while addressing the specific requirements of mutable objects in Java.

Next TopicJava instanceOf() Generics

← prev next →