It is often desirable to have immutable objects, objects that cannot be modified once constructed. Typically, an immutable object has fields that are declared as final and are set in the object constructor. There are getters for the fields, but no setters since the values cannot be saved. Once created, the object state doesn’t change and the objects can be shared across different threads since the state is fixed. There are plenty of caveats to that statement, for example if you have a list, while the list field reference may be final, the list itself may be able to change and have values added and removed which would spoil the immutability. <\/p>\n
Achieving this state can often be difficult because we rely on a number of tools and frameworks that may not support immutability such as any framework that builds an object by creating it and then setting values on it. <\/p>\n
However, one way around this would be to take a mutable object and make it immutable through interfaces. We do this by creating an interface that represents all the getters for an object, but none of the setters.<\/p>\n
Given a domain entity of a person with an id, first and last name fields we can define an immutable interface :<\/p>\n
\r\npublic interface ImmutablePerson {\r\n\tpublic int getId();\r\n\tpublic String getFirstName();\r\n\tpublic String getLastName();\r\n}\r\n<\/pre>\nWe can then implement this interface in our person class :<\/p>\n
\r\npublic class PersonEntity implements ImmutablePerson {\r\n\tprivate int id;\r\n\tprivate String firstName;\r\n\tprivate String lastName;\r\n\r\n\tpublic int getId() {\r\n\t\treturn id;\r\n\t}\r\n\r\n\tpublic void setId(int id) {\r\n\t\tthis.id = id;\r\n\t}\r\n\r\n\tpublic String getFirstName() {\r\n\t\treturn firstName;\r\n\t}\r\n\r\n\tpublic void setFirstName(String firstName) {\r\n\t\tthis.firstName = firstName;\r\n\t}\r\n}\r\n<\/pre>\nOur API deals with the PersonEntity<\/code> class internally, but exposes the object as the ImmutablePerson<\/code> only.<\/p>\n\r\npublic ImmutablePerson loadPerson(int id) {\r\n\tPersonEntity result = someLoadingMechanism.getPerson(id);\r\n\tresult.setxxxxx(somevalue); \/\/we can change it internally\r\n\treturn result; \/\/once it has been returned it is only accessed as an immutable person\r\n}\r\n<\/pre>\nTo return a mutable instance for modification, you can return the PersonEntity<\/code>. Alternatively, you can add a MutablePerson<\/code> interface with just the setters and implement that. Unless you want to keep casting between the Immutable\/Mutable types, the MutablePerson<\/code> interface can extend the ImmutablePerson<\/code> interface so the writable version is also readable.<\/p>\n\r\npublic interface MutablePerson extends ImmutablePerson {\r\n\tpublic void setId(int id) {\r\n\tpublic void setFirstName(String firstName);\r\n\tpublic void setLastName(String lastName);\r\n}\r\n<\/pre>\n