Dinesh on Java

The object cloning is a way to create exact copy of an object. For this purpose, clone() method of Object class is used to clone an object.

The java.lang.Cloneable interface must be implemented by the class whose object clone we want to create. If we don’t implement Cloneable interface, clone() method generates CloneNotSupportedException.

The clone() method is defined in the Object class. Syntax of the clone() method is as follows:

protected Object clone() throws CloneNotSupportedException  

What are different types of cloning in Java?
– Java supports two type of cloning: – Deep and shallow cloning. By default shallow copy is used in Java. Object class has a method clone() which does shallow cloning.

What is Shallow copy?
– In shallow copy the object is copied without its contained objects.
Shallow clone only copies the top level structure of the object not the lower levels.
It is an exact bit copy of all the attributes.

The shallow copy is done for obj and new object obj1 is created but contained objects of obj are not copied.

It can be seen that no new objects are created for obj1 and it is referring to the same old contained objects. If either of the containedObj contain any other object no new reference is created.

Why use clone() method ?
– The clone() method saves the extra processing task for creating the exact copy of an object. If we perform it by using the new keyword, it will take a lot of processing to be performed that is why we use object cloning.

Example of clone() method

class Student implements Cloneable{  
int rollno;  
String name;  
  
Student(int rollno,String name){  
this.rollno=rollno;  
this.name=name;  
}  
  
public Object clone()throws CloneNotSupportedException{  
return super.clone();  
}  
  
public static void main(String args[]){  
try{  
Student s1=new Student(111,"dinesh");  
  
Student s2=(Student)s1.clone();  
  
System.out.println(s1.rollno+" "+s1.name);  
System.out.println(s2.rollno+" "+s2.name);  
  
}catch(CloneNotSupportedException c){}  
  
}  
}  

As you can see in the above example, both reference variables have the same value. Thus, the clone() copies the values of an object to another. So we don’t need to write explicit code to copy the value of an object to another.

If we create another object by new keyword and assign the values of another object to this one, it will require a lot of processing on this object. So to save the extra processing task we use clone() method.

What is deep copy and how it can be achieved?
– In deep copy the object is copied along with the objects it refers to. Deep clone copies all the levels of the object from top to the bottom recursively.

When a deep copy of the object is done new references are created.

Disadvantages of using Serialization to achieve deep cloning –

• Serialization is more expensive than using object.clone().
• Not all objects are serializable.
• Serialization is not simple to implement for deep cloned object.

What is difference between deep and shallow cloning?
– The differences are as follows:

Consider the class:

public class MyData{
String id;
Map myData;
}

The shallow copying of this object will have new id object and values as “” but will point to the myData of the original object. So a change in myData by either original or cloned object will be reflected in other also. But in deep copying there will be new id object and also new myData object and independent of original object but with same values.

Shallow copying is default cloning in Java which can be achieved using clone() method of Object class. For deep copying some extra logic need to be provided.