Contents
Can you please explain immutability?
To explain what immutability is, first we need to understand what mutability is. Mutability means the possibility to change the state of an entity while its identity remains the same. Obviously, immutability is the opposite. Once an object is constructed, it will have the same state for as long as it lives.
How do you explain immutability?
In object-oriented and functional programming, an immutable object (unchangeable object) is an object whose state cannot be modified after it is created. This is in contrast to a mutable object (changeable object), which can be modified after it is created.
What is the benefit of immutability?
Immutable objects offer a number of advantages for building reliable applications. As we don’t need to write defensive or protective code to keep application state consistent, our code can be simpler, more concise, and less error-prone than when we define mutable objects.
What is an example of immutability?
String is an example of an immutable type. A String object always represents the same string. StringBuilder is an example of a mutable type. It has methods to delete parts of the string, insert or replace characters, etc.
What is an example of something that is immutable?
There are many things in life that are immutable; these unchangeable things include death, taxes, and the laws of physics. The adjective immutable has Latin roots that mean “not changeable.” The Latin prefix for not is in, but the spelling changes when the prefix is put before the consonant m.
Which is an example of immutability in Java?
A similar concept can be applied to immutable objects. For instance, if ObjectA and ObjectB are immutable and equal, one can replace the other and, therefore, only one of them would need to be maintained on the heap while the other can be GCed instantly (assuming equals/hashcode has been implemented correctly).
What happens when mutation is done in Java?
If mutation is done upon the change of every attribute, then immutability will backfire by creating lots of garbage for collection. It depends on what the system does. For instance, enrichment, CRUD operations, state management, etc. It depends on how concurrent the system is and what trade-offs/risks are suitable.
Which is the best builder pattern for immutable objects?
The builder pattern is much better-suited for constructing immutable objects. Extensions can be made without the need to break existing code, and setters (or withXXs) can be chained to create a nice DSL effect.