I am looking for some efficient way for building a immutable class, just like Java's String class.
An object is immutable if none of its fields can be modified, so those fields must be final
. If you don't want your object to be subclassed, you can make the class itself final
as well, just like String is.
To easily construct an immutable object with a lot of information, you should look at the Factory Pattern
For more information, see Wikipedia
If you populate all fields using the constructor and make the fields final - you are partway there.
If the fields use custom types - you may need to make them immutable as well.
Any fields that are collections should use the unmodifiable collections - to be on the safe side.
You need to worry about the object graph!
Any methods on the object need to take care with non-final fields. E.g. String.add creates a new String. If you need to mutate one field - do so via a copy constructor.
Finally make the object final.
- All the fields must be
private
and preferablyfinal
- Ensure the class cannot be overridden - make the class final, or use static factories and keep constructors private
- Fields must be populated from the Constructor/Factory
- Don't provide any setters for the fields
- Watch out for collections. Use
Collections.unmodifiable*
. Also, collections should contain only immutable Objects - All the getters must provide immutable objects or use defensive copying
- Don't provide any methods that change the internal state of the Object.
Tom Hawtin pointed out that final
can be optional. String
class
has a cache hash
var that is only assigned when the hash function is called.
Joshua Bloch tells you how to do it. Have a look at his "Effective Java".
Here is a link to an article on javaranch best article ever read for immutable objects