Comments on: Learn This: When and how to make Immutable objects

By: Himanshu

Himanshu — Mon, 14 Jun 2010 16:28:19 +0000

The example is still not immutable.
In the constructor you take Date as a parameter, so when someone instantiates this, it would be passed in. So the reference is held outside and can be modified post object creation. So the immutable parameters in the constructors should be cloned before assigning to private instance variables.

By: Pages tagged "immutable"

Pages tagged "immutable" — Tue, 24 Mar 2009 17:32:33 +0000

[...] bookmarks tagged immutable Learn This: When and how to make Immutable objects… saved by 3 others gryteke bookmarked on 03/24/09 | [...]

By: willcodejavaforfood

willcodejavaforfood — Tue, 10 Mar 2009 15:59:55 +0000

I’d say that getters must return immutable objects or copies is important enough that is should be in the bullet point list.

By: Alex Miller

Alex Miller — Thu, 26 Feb 2009 03:00:50 +0000

Marking the fields final is far more important than marking the class final. These two things are completely different. Marking the fields final indicates special things in the Java Memory Model – namely that the value MUST be set by the end of construction (or you will get a compile error) and if the object is safely published, all threads are guaranteed to see the values you set during the constructor *without further synchronization*. Without the final on the fields, those guarantees are not given by the JMM.

By: Giorgio Sironi

Giorgio Sironi — Tue, 24 Feb 2009 19:58:21 +0000

Nice introduction on immutable objects. I use immutable objects to implement Value Object (see DDD).

By: tont0r

tont0r — Tue, 24 Feb 2009 19:41:08 +0000

Alex,

Good catch on the Date. I cant believe I let that slip through because I have definitely run into that situation before. However, I did opt for making the whole class final in the example. You are right though, for the purpose of this example, I should have marked all of them as final instead.

I agree on the setters being okay and as you said, they are fine as long as they return new instances of your class. In the example I gave, there wasnt too much of a reason for it. But I suppose for the purpose of an example I can throw an example up there.

Thanks for the input!
Marcel

By: Alex Miller

Alex Miller — Tue, 24 Feb 2009 19:35:37 +0000

Immutable classes are indeed quite important but I wanted to mention a few things:

1) You mention the importance of marking fields final but you didn’t actually do so in your example. This is of critical importance to the Java Memory Model.

2) Regardless of final usage, this class is actually not immutable. You return the Date field from the getter and Date is a mutable class that the caller of the getDate() can modify, thus modifying the data of this class. It is best to either wrap objects like this in immutable wrappers or copy the data so it cannot reach back to you.

3) Examples like your “constants” are usually better implemented with an enum in Java, although it depends a bit on the usage.

4) Even setters are ok for an immutable class…as long as they return a new immutable copy of the object. See BigInteger/BigDecimal for good examples.

5) Your “companion class” pattern is more commonly called a Builder.