Shallow copy and deep copy is related with cloning process so before go
into the deep of shallow and deep copy we need to understand what is clone in
java. Clone is nothing but the process of copying one object to produce the
exact object, which is not guaranteed. We all know in Java object is referred
by reference we can not copy one object directly to another object. So we have
cloning process to achieve this objective. Now one question arise in mind why
we need this process so the answer is whenever we need local copy of the object
to modify the object in some method but not in method caller. So we can define Cloning as “create
a copy of object “ .I think now we
are some how clear about the cloning but there
is more on it depending upon how we are doing this copy, we can divide
cloning in two types.
Before going into the deep of shallow and deep copy we need to understand
how we achieve cloning in java.
How will you achieve cloning in java?
In Java everything is achieved through class, object and interface .By
default no Java class support cloning but Java provide one interface called Cloneable, which is
a marker
interface and by implementing this interface we can
make duplicate copy of our object by calling clone() method of java.lang.Object class.
This Method is protected inside the object class and Cloneable interface is a marker interface and this method also throw CloneNotSupportedException
if we have not implement this interface and try to call clone() method of
Object class. By default any clone() method
gives shallow copy of the object i.e. if we invoke super. clone() then it’s
a shallow copy but if we want to deep copy we have to override the clone() method and
make it public and give own definition of making copy of object. Now we let’s
see what is shallow and deep copy of
object in Java programming language.
Shallow Copy
Whenever we use default implementation of clone method we get shallow
copy of object means it create new instance and copy all the field of object to
that new instance and return it as object type we need to explicitly
cast it back to our original object. This is shallow copy of the object. clone() method of
the object class support shallow copy of the object. If the object contains
primitive as well as non primitive or reference type variable In shallow copy, the cloned object also refers
to the same object to which the original object refers as only the object
references gets copied and not the referred objects themselves. That's why the
name shallow copy or shallow cloning in Java. If only primitive type fields or Immutable
objects are there then there is no difference between shallow and deep copy
in Java.
Deep Copy
Whenever we need own meaning of copy not to use default implementation we
call it as deep copy, whenever we need deep copy of the object we need to
implement according to our need. So for deep copy we need to ensure all the
member class also implement the Cloneable interface
and override the clone() method of the object class. After
that we override the clone() method in all those classes even
in the classes where we have only primitive type members otherwise we would not
be able to call the protected clone() method of Object class on
the instances of those classes inside some other class. It’s typical
restriction of the protected access.
Difference between Shallow and Deep Copy in
Java
I think now we know what is deep and shallow copy of object in Java, let
see some difference between them so that we can get some more clarity on them.
- When we call Object.clone(), this method
performs a shallow copy of object, by copying data field by field, and if we
override this method and by convention first call super.clone(), and then modify
some fields to "deep" copy, then we get deep copy of object. This
modification is done to ensure that original and cloned object are independent
to each other.
- In shallow copy main or parent object is copied, but
they share same fields or children if fields are modified in one parent object
other parent fields have automatic same changes occur,but in deep copy this is
not the case.
- If our parent object contains only primitive value
then shallow copy is good for making clone of any object because in new object
value is copied but if parent object contains any other object then only reference value is copied in new parent object and both will point to same
object so in that case according to our need we can go for deep copy.
- Deep copy is expensive as compare to shallow copy in
terms of object creation, because it involves recursive copying of data from
other mutable objects, which is part of original object.
This is all about deep copy and shallow copy of objects in Java. Now the
question comes when we use shallow copy and when go for deep copy , so answer
would be simple that if the object has
only primitive fields or Immutable objects, then obviously we will go for
shallow copy, but if the object has references to other mutable objects, then
based on the requirement, shallow copy or deep copy can be chosen. Means if the references are not modified anytime,
then there is no point in going for deep copy, We can go for shallow copy. But
if the references are modified often, then you need to go for deep copy. Again
there is no hard and fast rule, it all depends on the requirement.
Hope this article will help to make clear about deep and shallow copy of
cloning process.
Related Java Interview Questions articles from Java67 Blog
Difference
between ConcurrentHashMap vs HashMap in Java
Previous Topic
