- Shallow Copy
- Deep Copy
How to Clone in java?
Deep CopyWhenever 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
- 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.