Writing or creating immutable classes in Java is becoming popular day by day, because
of concurrency and multithreading advantage provided by immutable objects. Immutable
objects offers several benefits over conventional mutable object, especially while
creating concurrent Java application. Immutable object not only guarantees safe
publication of object’s state, but also can be shared among other threads
without any external synchronization. In fact JDK
itself contains several immutable classes like String, Integer and other wrapper
classes. For those, who doesn’t know what is immutable class or object,
Immutable objects are those, whose state can not be changed once created e.g. java.lang.String, once
created can not be modified e.g. trim, uppercase, lowercase. All modification in
String result in new object, see why String is immutable in Java
for more details. In this Java programming tutorial, we will learn, how to
write immutable class in Java or how to make a class immutable. By the way making
a class immutable is not difficult on code level, but its the decision to make,
which class mutable or immutable which makes difference. I also suggest reading,
Java Concurrency in Practice
to learn more about concurrency benefit offered by Immutable object.
What is immutable class in Java
As said earlier, Immutable classes are those class, whose object can not be modifiedonce created, it means any modification on immutable object will result in
another immutable object. best example to understand immutable and mutable
objects are, String and StringBuffer. Since
String is immutable class, any change on existing string object will result in
another string e.g. replacing a character into String, creating substring from String,
all result in a new objects. While in case of mutable object like StringBuffer, any
modification is done on object itself and no new objects are created. Some times
this immutability of String can also cause security hole, and that the reason why password should be stored on char
array instead of String.
How to write immutable class in Java
Despite of few disadvantages, Immutable object still offers several
benefits in multi-threaded programming and it’s a great choice to achieve thread safety in Java code.
here are few rules, which helps to make a class immutable in Java :
1. State of immutable object can not be modified after construction, any
modification should result in new immutable object.
2. All fields of Immutable class should be final.
3. Object must be properly constructed i.e. object reference must not
leak during construction process.
4. Object should be final in order to restrict sub-class for altering
immutability of parent class.
By the way, you can still create immutable object by violating few rules,
like String has its hashcode in non final field,
but its always guaranteed to be same. No matter how many times you calculate it,
because it’s calculated from final fields, which is guaranteed to be same. This
required a deep knowledge of Java memory model, and can create subtle race conditions if not
addressed properly. In next section we will see simple example of writing
immutable class in Java. By the way, if your Immutable class has lots of optional and mandatory fields, then you can also use Builder design pattern to make a class Immutable in Java.
Immutable Class Example in Java
Here is complete code example of writing immutable class in Java. We have
followed simplest approach and all rules for making a class immutable,
including it making class final to avoid
putting immutability at risk due to Inheritance and Polymorphism.
public final class Contacts {
private final String name;
private final String mobile;
public Contacts(String name, String mobile) {
this.name = name;
this.mobile = mobile;
}
public String getName(){
return name;
}
public String getMobile(){
return mobile;
}
}
This Java class is immutable, because its state can not be changed once
created. You can see that all of it’s fields are final. This is one of the most
simple way of creating immutable class in Java, where all fields of class also
remains immutable like String in above case. Some time you may need to write
immutable class which includes mutable classes like java.util.Date, despite
storing Date into final field it can be modified internally, if
internal date is returned to the client. In order to preserve immutability in
such cases, its advised to return copy of original object, which is also
one of the Java best practice. here is
another example of making a class immutable in Java, which includes mutable member
variable.
public final class
ImmutableReminder{
private final Date remindingDate;
public ImmutableReminder (Date remindingDate)
{
if(remindingDate.getTime() < System.currentTimeMillis()){
throw new IllegalArgumentException("Can not
set reminder” +
“ for past time: " + remindingDate);
}
this.remindingDate = new Date(remindingDate.getTime());
}
public Date getRemindingDate() {
return (Date) remindingDate.clone();
}
}
In above example of creating immutable class, Date is a mutable object. If getRemindingDate() returns
actual Date object than despite remindingDate being final variable, internals of
Date can be modified by client code. By returning clone() or copy of
remindingDate, we avoid that danger and preserves immutability of
class.
Benefits of Immutable Classes in Java
As I said earlier Immutable classes offers several benefits, here are few
to mention:
1) Immutable objects are by default thread safe, can be shared
without synchronization in concurrent environment.
2) Immutable object simplifies development, because its easier to share
between multiple threads without external synchronization.
3) Immutable object boost performance of Java application by reducing synchronization in code.
4) Another important benefit of Immutable objects is reusability, you can cache Immutable object and reuse them, much like String literals and Integers. You can use static factory methods to provide methods like valueOf(), which can return an existing Immutable object from cache, instead of creating a new one.
Apart from above advantages, immutable object has disadvantage of
creating garbage as well. Since immutable object can not be reused and they are
just a use and throw. String being a prime example, which can create lot of
garbage and can potentially slow down application due to heavy garbage collection, but
again that's extreme case and if used properly Immutable object adds lot of
value.
That's all on how to write immutable class in Java. we have seen
rules of writing immutable classes, benefits offered by immutable objects and
how we can create immutable class in Java which involves mutable fields. Don’t
forget to read more about concurrency benefit offered by Immutable object in
one of the best Java book recommended to Java programmers, Concurrency Practice in Java.
Related Java programming concepts and tutorials
Source:http://javarevisited.blogspot.com/2013/03/how-to-create-immutable-class-object-java-example-tutorial.html
Tidak ada komentar:
Posting Komentar