Immutable objects are ones which don't change after initial creation. Such objects are frequently desirable because they are simple and can be safely shared even in multi-threading contexts. This makes them great for functional and concurrent scenarios. The rules for creating such objects are well-known:
Writing classes that follow these rules is not hard but does involve a fair bit of boiler plate code and is prone to error. Here is what such a class might look like in Java:
Groovy makes it easier to create such classes using the @Immutable annotation. You only need this:
The "other code" shown above is added at compile time. All of the methods you see above will be there (and you can use them from Java of course). You just don't need to develop and maintain them.
A class created using @Immutable has the following characteristics:
toStringmethods are provided based on the property values.
Cloneableobjects and arrays are defensively copied on the way in (constructor) and out (getters).
clonemethod. For your own classes, it is up to you to define this method and use deep cloning if appropriate.
Mapobjects are wrapped by immutable wrapper classes (but not deeply cloned!).
@Immutableclasses are allowed but for an otherwise possible mutable property type, an error is thrown.
hashCodemethods. Use at your own risk!