What is Immutable Class in Java

Upasana | December 08, 2019 | 2 min read | 1,409 views | Multithreading and Concurrency

When the state of object can not be changed after its construction then the object is called Immutable.

Benefits of Immutable Objects

Inherent thread-safety: Immutable objects are inherently thread-safe, thus help writing multi-threading code without much worries.
Cacheability: Because Immutable objects do not change their value, we can freely cache them and be confident that their value won’t change.
Good candidate for Hashing Keys: Immutable objects are good candidate for hash keys because their hashcode can be cached and reused for better performance. They make the best HashMap keys.
Easy to understand: Immutable classes are easy to understand, as they possess a single state, which is controlled by their constructor.

Immutable classes are ideal for representing ADT’s (Abstract Data Type) value.

All classes should be designed to be immutable unless there is a specific reason not to do so.

— Joshua Bloch

All fields should be declared final
Class itself is declared final so that the derived classes do not make it Mutable.
this reference should not be allowed to escape during object construction such as in anonymous inner classes (for example adding action listener)
Any field that contains reference to mutable objects (such as arrays, collections, StringBuffer, etc)
- Are private
- Are never returned or exposed to the caller
- Are the only reference to the Objects that they refer
- Do not change the state of the referenced object after the construction.
- If mutable fields must be returned to the caller, then a defensive copy should be returned so that the changes do not reflect in the inner data structure.
  For example,
  Defensive copy of mutable object
  public List getList() { return Collections.unmodifiableList(list); (1) }
  1 defensive copy of the mutable field before returning it to caller
- If a mutable Object is passed in the constructor (like an array), then Immutable class should first make a defensive copy of the mutable object before storing its reference.