Java Object Cloning with Examples

Cloning is the process of creating an exact copy of an existing object in the memory.

For implementing the cloning feature in Java, the clone() method of a java.lang.Object class is used to clone an existing object. This method creates an exact copy of an object on which it is called through the field-by-field assignment and returns the reference of that object.

Not all the objects in Java are eligible for the cloning process. The class whose objects we want to clone that class must implement Cloneable Interface. If we do not implement Cloneable interface and try to clone the object, the clone() method generates CloneNotSupportedException.

A cloneable interface is a marker interface in Java that is used to provide the marker for the cloning process. A class implements the Cloneable interface to indicate to the Object.clone() method that it is legal for that method to make a field-for-field copy of instances of that class.

Advantage of Object cloning in Java

Types of Cloning in Java

Shallow Cloning

Shallow Cloning is the default cloning process in Java and it is done by invoking the clone() method where a shallow copy of the original object will be created with the exact field. In case the original object has references to some other objects as fields, then only the references of that object will be cloned instead of new object creation. if we change the value of the cloned objects then it will be reflected in the original as well. Thus, shallow cloning is dependent on the original object. A shallow copy is not 100% disjoint from the original object and not 100% independent of the original object.

After the definition of Shallow Cloning let's understand it by this given below example:

  class Address {
    String village;
    String city;
    String state;
  
    public Address(String village, String city, String state) {
      this.village = village;
      this.city = city;
      this.state = state;
    }
  }
  
  class Person implements Cloneable {
    String name;
    int age;
    Address address;
  
    public Person(String name, int age, Address address) {
      this.name = name;
      this.age = age;
      this.address = address;
    }
  
    // Default version of clone() method. It creates shallow copy of an object.
    protected Object clone() throws CloneNotSupportedException {
      return super.clone();
    }
  }
  
  public class ShallowCloningDemo {
    public static void main(String[] args) {
  
      Address addressObj = new Address("MG Road", "Bengaluru", "Karnataka");
      Person person1 = new Person("Manoj", 25, addressObj);
      Person person2 = null;
  
      try {
        // Creating a clone of person1 and assigning it to person2
        person2 = (Person) person1.clone();
      } catch (CloneNotSupportedException e) {
        e.printStackTrace();
      }
  
      // Printing the person1 (original object) data
      System.out.println("Original object (person1) data:");
      System.out.println(person1.name + " " + person1.age + " " + person1.address.village 
      + " " + person1.address.city + " " + person1.address.state);
  
      // Modifying person2 (cloned object) data
      person2.age = 35;
      person2.address.village = "Electronic City";
  
      System.out.println("\nCloned object (person2) data:");
      System.out.println(person2.name + " " + person2.age + " " + person2.address.village 
      + " " + person2.address.city + " " + person2.address.state);
  
      // This change will be reflected in the person1 reference object
      System.out.println("\nOriginal object (person1) data after modifying cloned object:");
      System.out.println(person1.name + " " + person1.age + " " + person1.address.village + " " 
      + person1.address.city + " " + person1.address.state);
    }
  }

Original object (person1) data:
Manoj 25 MG Road Bengaluru Karnataka

Cloned object (person2) data:
Manoj 35 Electronic City Bengaluru Karnataka

Original object (person1) data after modifying cloned object:
Manoj 25 Electronic City Bengaluru Karnataka

Deep Cloning

A deep copy of an object will have an exact copy of all the fields of the original object just like a shallow copy. But in addition, if the original object has any references to other objects as fields, then copies of those objects are also created by calling the clone() method on them. That means cloned object and original object will be 100% disjoint. Both the objects will be 100% independent of each other. Any changes made to cloned object will not be reflected in the original object or vice-versa.

To create a deep copy of an object, we have to override the clone() method as demonstrated in the given below example:

  class Address implements Cloneable {
    String village;
    String city;
    String state;
  
    public Address(String village, String city, String state) {
      this.village = village;
      this.city = city;
      this.state = state;
    }
  
    protected Object clone() throws CloneNotSupportedException {
      return super.clone();
    }
  }
  
  class Person implements Cloneable {
    String name;
    int age;
    Address address;
  
    public Person(String name, int age, Address address) {
      this.name = name;
      this.age = age;
      this.address = address;
    }
  
    // Overriding clone() method to create a deep copy of an object.
    protected Object clone() throws CloneNotSupportedException {
      Person person = (Person) super.clone();
      person.address = (Address) address.clone();
      return person;
    }
  }
  
  public class DeepCloningDemo {
    public static void main(String[] args) {
  
      Address addressObj = new Address("MG Road", "Bengaluru", "Karnataka");
      Person person1 = new Person("Manoj", 25, addressObj);
      Person person2 = null;
  
      try {
        // Creating a clone of person1 and assigning it to person2
        person2 = (Person) person1.clone();
      } catch (CloneNotSupportedException e) {
        e.printStackTrace();
      }
  
      // Printing the person1 (original object) data
      System.out.println("Original object (person1) data:");
      System.out.println(person1.name + " " + person1.age + " " + person1.address.village 
          + " " + person1.address.city + " " + person1.address.state);
  
      // Modifying person2 (cloned object) data
      person2.age = 35;
      person2.address.village = "Electronic City";
  
      System.out.println("\nCloned object (person2) data:");
      System.out.println(person2.name + " " + person2.age + " " + person2.address.village 
          + " " + person2.address.city + " " + person2.address.state);
  
      // This change will be reflected in the person1 reference object
      System.out.println("\nOriginal object (person1) data after modifying cloned object:");
      System.out.println(person1.name + " " + person1.age + " " + person1.address.village + 
          " " + person1.address.city + " " + person1.address.state);
    }
  }

Object Cloning in Java

Advantage of Object cloning in Java

Types of Cloning in Java

Shallow Cloning

Deep Cloning

Object Cloning - Interview Questions and Asnwers

Currently No Video available