Once an immutable class is created, its state cannot be modified, and any operation will return a new object. To implement immutable classes in Java, the following steps must be followed: 1. Declare the class as final; 2. Set all fields to private and final; 3. Only getter methods are provided, not setters are provided; 4. All fields must be initialized in the constructor; 5. For fields of mutable types, defensive copies are made during assignment and acquisition. In addition, Java 9 supports built-in immutable collections such as List.of(), etc., which helps reduce boilerplate code and prevents accidental modifications. As long as you pay attention to the design of the class and internal state protection, you can achieve true immutability in Java.

Immutability means that once an object is created, its state cannot be changed. Any operation that would normally modify the object instead returns a new object with the updated state. This concept is important in programming because it helps avoid side effects, makes code easier to reason about, and improves thread safety.

Java isn't built around immutability by default — most objects are mutable unless designed otherwise. But you can definitely create immutable classes if you follow certain rules.

What Makes a Class Immutable in Java?

An immutable class must ensure that its internal state remains constant after creation. Here's what you need to do:

• Make the class final — prevents subclasses from changing behavior.
• Make all fields private and final — ensures they can't be modified externally or internally after construction.
• Don't provide setter methods — only getters, if needed.
• Initialize all fields via constructor only — no other way to change values ??later.
• If a field is mutable (like collections or other objects), return defendive copies — so changes don't affect the internal state.

For example, if your class contains a List<string></string> , returning the list directly could allow outside code to modify it. Instead, return a new copy of the list inside a getter.

Common Mistakes That Break Immutability

Even when trying to build immutable classes, some common mistakes can break immutability:

• Returning references to mutable internal objects , like collections or arrays.
• Allowing subclassing , which might override methods and introduce mutability.
• Initializing fields outside the constructor , for example through setters or public fields.

Let's say you have a class with a Date field. If you expose that date object directly, someone could call setTime() on it and change your supposedly immutable object's internal state.

So always:

• Return defensive copies of mutable objects.
• Make sure all fields are initialized in the constructor.
• Avoid any method that changes the object's state.

How to Achieve Immutability Step by Step

Here's how to actually implement an immutable class in Java:

1. Declare the class as final .
2. Make all fields private and final .
3. Only define getters — no setters.
4. Initialize all fields through the constructor.
5. If using mutable types (like List , Date , etc.), make defensive copies during both assignment and retrieval.

 public final class Person {
    private final String name;
    private final List<String> hobbies;

    public Person(String name, List<String> hobbies) {
        this.name = name;
        this.hobbies = new ArrayList<>(hobbies); // Defensive copy
    }

    public String getName() {
        return name;
    }

    public List<String> getHobbies() {
        return new ArrayList<>(hobbies); // Return a copy
    }
}

This way, even if someone modifies the list returned by getHobbies() , the original object stays unchanged.

Use Built-in Immutable Collections When Possible

Since Java 9, there are built-in immutable collections like List.of() , Set.of() , and Map.of() . These are handy when you want to return unmodifiable collections without manually wrapping or copying them.

Using these helps reduce boilerplate and avoids accidental modification attempts. Trying to add or remove elements from such collections will throw an UnsupportedOperationException .

Basically that's it. As long as you pay attention to the design of the class and the protection of internal state, you can achieve true immutability in Java.

The above is the detailed content of What is Immutability and how to achieve it in Java?. For more information, please follow other related articles on the PHP Chinese website!