immutable object

A classic example of an immutable object is an instance of the Java String class.

String s = "ABC";

s.toLowerCase();

The method toLowerCase() will not change the data "ABC" that s contains. Instead, a new String object is instantiated and given the data "abc" during its construction. A reference to this String object is returned by thetoLowerCase() method. To make the String s contain the data "abc", a different approach is needed.

s = s.toLowerCase();

Now the String s references a new String object that contains "abc". There is nothing in the syntax of the declaration of the class String that enforces it as immutable; rather, none of the String class's methods ever affect the data that a String object contains, thus making it immutable.

By default, fields and local variables are mutable. They can be made immutable using the final keyword.

int i = 42;

i = 43; // OK

final int j = 42;

j = 43; // does not compile

Primitive wrappers (Integer, Long, Short, Double, Float, Character, Byte, Boolean) are also all immutable. Immutable classes can be implemented by following a few simple guidelines

·      Don't provide "setter" methods — methods that modify fields or objects referred to by fields.

·      Make all fields final and private.

·      Don't allow subclasses to override methods. The simplest way to do this is to declare the class as final. A more sophisticated approach is to make the constructor private and construct instances in factory methods.

·      If the instance fields include references to mutable objects, don't allow those objects to be changed:

  Don't provide methods that modify the mutable objects.

   Don't share references to the mutable objects. Never store references to external, mutable objects passed to the constructor; if necessary, create copies, and store references to the copies. Similarly, create copies of your internal mutable objects when necessary to avoid returning the originals in your methods.