what is immutable and how to make a class immutable in java

Tweet

 Immutability is a fundamental concept in Java that plays a crucial role in ensuring the predictability and safety of your code. An immutable class is a class whose instances cannot be modified after they are created.

In other words, the state of an immutable object remains constant throughout its lifetime. This concept has significant benefits in terms of thread safety, debugging, and code quality. In this blog post, we'll explore what immutability is and how to create an immutable class in Java, step by step.

Step 1: Declare the Class as final

The first step in creating an immutable class is to declare it as final. This prevents any other class from extending it, which is a crucial aspect of ensuring immutability.

java
public final class ImmutableClass {
    // Class members and methods go here
}

Step 2: Make Fields Private and Final

All fields in an immutable class should be declared as private and final. Making them private restricts access from external sources, and marking them final ensures that their values cannot be changed after initialization.

java
public final class ImmutableClass {
    private final int field1;
    private final String field2;
    // Other fields go here

    public ImmutableClass(int field1, String field2) {
        this.field1 = field1;
        this.field2 = field2;
        // Initialize other fields here
    }
}

Step 3: Provide Accessor Methods

To access the values of the fields, provide getter methods for each field. These methods allow clients to read the values but not modify them.

java
public final class ImmutableClass {
    private final int field1;
    private final String field2;

    public ImmutableClass(int field1, String field2) {
        this.field1 = field1;
        this.field2 = field2;
    }

    public int getField1() {
        return field1;
    }

    public String getField2() {
        return field2;
    }
}

Step 4: Ensure Mutable Objects Are Handled Correctly

If your immutable class contains references to mutable objects (e.g., collections), make sure they are handled properly. You should return a copy of the mutable object rather than the object itself in getter methods to avoid unintentional changes.

java
public final class ImmutableClass {
    private final List<String> immutableList;

    public ImmutableClass(List<String> immutableList) {
        this.immutableList = new ArrayList<>(immutableList); // Create a defensive copy
    }

    public List<String> getImmutableList() {
        return new ArrayList<>(immutableList); // Return a copy to keep the original list immutable
    }
}

Step 5: Prevent Subclassing

To ensure the class remains immutable, prevent subclassing by declaring all constructors as private and providing a factory method to create instances.

java
public final class ImmutableClass {
    private final int field1;
    private final String field2;

    private ImmutableClass(int field1, String field2) {
        this.field1 = field1;
        this.field2 = field2;
    }

    public static ImmutableClass createInstance(int field1, String field2) {
        return new ImmutableClass(field1, field2);
    }

    public int getField1() {
        return field1;
    }

    public String getField2() {
        return field2;
    }
}

Step 6: Make Defensive Copies When Necessary

If your class deals with mutable objects, make defensive copies to ensure that the original objects are not modified outside the class.

java
public final class ImmutableClass {
    private final List<String> immutableList;

    private ImmutableClass(List<String> immutableList) {
        this.immutableList = new ArrayList<>(immutableList);
    }

    public static ImmutableClass createInstance(List<String> immutableList) {
        return new ImmutableClass(immutableList);
    }

    public List<String> getImmutableList() {
        return new ArrayList<>(immutableList);
    }
}

By following these steps, you can create a robust immutable class in Java. This ensures that the instances of your class remain constant, providing safety and predictability in your code.

Example Code:

Here's a complete example of an immutable class in Java:

java
public final class ImmutableClass {
    private final List<String> immutableList;

    private ImmutableClass(List<String> immutableList) {
        this.immutableList = new ArrayList<>(immutableList);
    }

    public static ImmutableClass createInstance(List<String> immutableList) {
        return new ImmutableClass(immutableList);
    }

    public List<String> getImmutableList() {
        return new ArrayList<>(immutableList);
    }
}

By following these guidelines, you can create a class that guarantees immutability and the associated benefits it provides.