What is Cloning in Java and its Types?

Object cloning means to create an exact copy of the original object.

Learn Coding in your Language! Enroll Here!

If a class needs to support cloning, it must implement java.lang.Cloneable interface and override clone() method from Object class. Syntax of the clone() method is :

protected Object clone() throws CloneNotSupportedException

If the object’s class doesn’t implement Cloneable interface then it throws an exception ‘CloneNotSupportedException’ .

Output :

Object2 is a clone of object1
obj1.a = 3 obj1.b = 4
obj2.a = 1 obj2.b = 2

Object Cloning in Java

The object cloning is a way to create exact copy of an object. The 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:

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 time to be performed that is why we use object cloning.

Advantage of Object cloning

Although Object.clone() has some design issues but it is still a popular and easy way of copying objects. Following is a list of advantages of using clone() method:

• You don’t need to write lengthy and repetitive codes. Just use an abstract class with a 4- or 5-line long clone() method.
• It is the easiest and most efficient way for copying objects, especially if we are applying it to an already developed or an old project. Just define a parent class, implement Cloneable in it, provide the definition of the clone() method and the task will be done.
• Clone() is the fastest way to copy array.

Disadvantage of Object cloning

Following is a list of some disadvantages of clone() method:

• To use the Object.clone() method, we have to change a lot of syntaxes to our code, like implementing a Cloneable interface, defining the clone() method and handling CloneNotSupportedException, and finally, calling Object.clone() etc.
• We have to implement cloneable interface while it doesn’t have any methods in it. We just have to use it to tell the JVM that we can perform clone() on our object.
• Object.clone() is protected, so we have to provide our own clone() and indirectly call Object.clone() from it.
• Object.clone() doesn’t invoke any constructor so we don’t have any control over object construction.
• If you want to write a clone method in a child class then all of its superclasses should define the clone() method in them or inherit it from another parent class. Otherwise, the super.clone() chain will fail.
• Object.clone() supports only shallow copying but we will need to override it if we need deep cloning.

Shallow Copy of an Object

Shallow cloning is the “default implementation” in Java. In overridden clone() method, if we are not cloning all the object types (not primitives), then we are making a shallow copy.

Deep Copying in Java

Deep cloning or deep copying is the desired behavior in most cases. In the deep copy, we create a clone that is independent of the original object and making changes in the cloned object should not affect the original object.

Let’s see how deep copy is created in Java.

//Modified clone() method in Employee class
@Override
protected Object clone() throws CloneNotSupportedException {
	Employee cloned = (Employee)super.clone();
	cloned.setDepartment((Department)cloned.getDepartment().clone());
	return cloned;
}

Here , we modified the Employee classes clone() method and added following clone method in Department class.

//Defined clone method in Department class.
@Override
protected Object clone() throws CloneNotSupportedException {
	return super.clone();
}

Now testing our cloning code gives the desired result and the name of the department will not be modified in the clone object.

public class TestCloning
{
	public static void main(String[] args) throws CloneNotSupportedException
	{
		Department hr = new Department(1, "Human Resource");

		Employee original = new Employee(1, "Admin", hr);
		Employee cloned = (Employee) original.clone();

		//Let change the department name in cloned object and we will verify in original object
		cloned.getDepartment().setName("Finance");

		System.out.println(original.getDepartment().getName());
		System.out.println(cloned.getDepartment().getName());
	}
}

Human Resource
Finance

Here, changing the state of the cloned object does not affect the original object.

So deep cloning requires satisfaction of following rules –

• No need to separately copy primitives.
• All the member classes in original class should support cloning and in clone method of original class in context should call super.clone() on all member classes.
• If any member class does not support cloning then in clone method, one must create a new instance of that member class and copy all its attributes one by one to new member class object. This new member class object will be set in cloned object.

Learn to code from industry experts! Enroll here

Deep Cloning with Serialization

Serialization is another easy way of deep cloning. In this method, we serialize the object to be cloned and de-serialize it back. Obviously, the object, that needs to be cloned, should implement Serializable interface.

Before going any further, you should be aware that this technique is not to be used lightly.

1. First of all, serialization is hugely expensive. It could easily be a hundred times more expensive than the clone() method.
2. Second, not all objects are Serializable.
3. Third, making a class Serializable is tricky and not all classes can be relied on to get it right.