Java immutable classes? [duplicate]

Answer 1

The main advantage of immutable classes is thread-safety. Most problems with threading come from having shared, mutable state. By making objects immutable, it is far easier to reason about them especially in multi-threaded environments.

The article says "creating immutable objects can hit performance of an app." I'm not sure why it says this. It's totally wrong. There is nothing inherent about immutable objects that could affect the application's performance.

Answer 2

The article says:

To make a class immutable you can define its all constructors private and then create a public static method to initialize and object and return it.

Actually, that is wrong. These two concepts aren't really related.

E.g. you could declare the constructor of your Employee class public and it would still be immutable.

Or you could pass a mutable Object as a parameter to the factory method or declare a mutator method

-> Employee would be mutable although you're using a factory method and a private constructor.

Answer 3

The example you have mentioned is of an Immutable Objects. Its widely used concepts in programming languages.

Quoting from the link above. The advantages are

• are simple to construct, test, and use
• are automatically thread-safe and have no synchronization issues
• do not need a copy constructor
• do not need an implementation of clone
• allow hashCode to use lazy initialization, and to cache its return value
• do not need to be copied defensively when used as a field
• make good Map keys and Set elements (these objects must not change state while in the collection)
• have their class invariant established once upon construction, and it never needs to be checked again
• always have "failure atomicity" (a term used by Joshua Bloch) : if an immutable object - throws an exception, it's never left in an undesirable or indeterminate state

Answer 4

In your given example he is making constructor as private, and thus controlling the object creation from outside directly.

Meaning : Since constructor is private, you can't do

Employee e = new Employee("steve","jobs"); 

from outside of this class.

By doing so, the programmer of this class, is taking object creation for this class into his control.

This is very beneficial, when you are writing very huge Server side class, for which creating an object may take lot of memory due to its size. Now how do you protect from your clients, of not creating more objects for your class?

Answer for above question is simple, by making your constructor private and you yourself creating objects for your class when ever you want in static method. Note: Static methods can be accessed directly by using class name.

Note: This kind of design patterns will be heavily used in singleton design patterns, which requires only one object for a given class.

Answer 5

-Why is it a good practice?

Because you can pass the class around and be sure it will never be modified by a "rogue" code. Same for Java Strings, they're immutable.

-Could you name a situation where this approach can be used?

It's very useful on big projects where many teams work together, or when designing a framework or an API. In these situations, since you're not responsible of parts of the code, you can never trust that an object you pass to other parts of the code won't be altered. Use immutability if you need to ensure the object won't be modified.

-What about constants or read only variables? Is not that very similar?

Not in Java because we have neither const nor read-only. All we have is the final keyword that ensures an object reference won't be modified beyond first assignment. But the underlying object can still be modified even if the reference can not. Immutable classes ensure an object state won't be altered after creation.

-In the article says, that this is not good for the performance of the application. But why?

Because every time you need to modify the object, you need to create new instances. Same for Strings, you can't do myString.append("42"), you need to do myString = myString+"42", which creates a new String object.

Answer 6

Immutable classes are:

• thread-safe by default (concurrent write never occurs)
• cachable

You can read a lot about them in the conext of the language Java in Effective Java.