Java, being an object-oriented programming language, allows developers to create and manipulate objects. In many cases, you might encounter a situation where you need to create a copy of an existing object. This process of creating an exact copy of an object is called object cloning. Understanding object cloning in Java is essential for various programming scenarios, such as creating copies of complex objects, implementing prototype patterns, and more. In this comprehensive guide, we’ll delve into the concept of object cloning in Java, explore different techniques, and discuss best practices.

What is Object Cloning?

The process of creating an exactly duplicate object is called cloning. The main purpose of cloning is to maintain a backup copy and preserve the state of the object. We can perform cloning by using the clone method of the Object class:

protected native Object clone() throws CloneNotSupportedException

In Java, to enable cloning for objects, the corresponding class must implement the Cloneable interface. This interface, found in the java.lang package, doesn’t contain any methods; it serves solely as a marker interface. Attempting to clone an object that doesn’t implement Cloneable will result in a CloneNotSupportedException.

class Test implements Cloneable {
    int i = 10;
    int j = 20;

    public static void main(String[] args) throws CloneNotSupportedException {
        Test t1 = new Test();
        Test t2 = (Test) t1.clone();
        t2.i = 888;
        t2.j = 999;
        System.out.println(t1.i + "......" + t1.j); //10...20
    }
}

Here, Test class implements the Cloneable interface, allowing its objects to be cloned using the clone() method.

What are different approaches to cloning objects in Java

Shallow cloning and deep cloning are two different approaches to cloning objects in Java.

Shallow Cloning

Shallow cloning refers to the process of creating a bitwise copy of an object. If the main object contains primitive variables, then exactly duplicate copies will be created in the cloned object. However, if the main object contains any reference variables, then corresponding objects won’t be created; instead, duplicate reference variables will be created, pointing to the old content object. The Object class’s clone method is meant for shallow cloning.

class Cat {
  int j;
  Cat(int j) {
    this.j = j;
  }
}

class Dog implements Cloneable {
  Cat c;
  int i;
  Dog(Cat c, int i) {
    this.c = c;
    this.i = i;
  }

  public Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}

class ShallowCloning {
  public static void main(String[] args) throws CloneNotSupportedException {
    Cat c = new Cat(20);
    Dog d1 = new Dog(c, 10);
    System.out.println(d1.i + "..............." + d1.c.j);
    Dog d2 = (Dog)d1.clone();
    d2.i = 888;
    d2.c.j = 999;
    System.out.println(d1.i + "........." + d1.c.j); // Output: 10 .... 999
  }
}

In shallow cloning, if changes are made to the content object through the cloned object reference, those changes will be reflected in the main object. To overcome this problem, we should use deep cloning.

Deep Cloning

Deep cloning refers to the process of creating an exactly duplicate independent copy, including the content object. In deep cloning, if the main object contains any primitive variables, then duplicate values will be created in the cloned object. If the main object contains any reference variables, then corresponding cloned objects will be created in the cloned copy. By default, the Object class’s clone method is meant for shallow cloning, but we can implement deep cloning explicitly by overriding the clone method in our class.

class Cat {
  int j;
  Cat(int j) { 
    this.j = j; 
  } 
} 

class Dog implements Cloneable {
  Cat c;
  int i;
   
  Dog(Cat c, int i) { 
    this.c = c;
    this.i = i;
  }

  public Object clone() throws CloneNotSupportedException {
    Cat c1 = new Cat(c.j);
    Dog d  = new Dog(c1, i);
    return d;
  } 
}

class DeepCloning {
  public static void main(String[] args) throws CloneNotSupportedException {
    Cat c = new Cat(20);
    Dog d1 = new Dog(c, 10);
    System.out.println(d1.i + "......." + d1.c.j);
    Dog d2 = (Dog) d1.clone();
    d2.i = 888;
    d2.c.j = 999;
    System.out.println(d1.i + "..........." + d1.c.j);
  }
}

When using a cloned object reference, if we perform any change to the contained object, those changes won’t be reflected in the main object.

Which cloning method is the best?

While shallow cloning creates a new object with copies of the original object’s fields, including references to the same content objects, deep cloning creates a completely independent duplicate copy, including new instances of all referenced objects. The choice between shallow and deep cloning depends on the specific requirements of the cloning operation and the desired behavior of the cloned objects.

If the object contains only primitive variables, then shallow cloning is the best choice. If the object contains reference variables, then deep cloning is the best choice.

Best Practices for Object Cloning

When implementing object cloning in Java, consider the following best practices:

1. Override clone() method: Always override the clone() method to ensure proper cloning behavior.
2. Implement Cloneable interface: If you choose to use the clone() method, implement the Cloneable interface to indicate that your class supports cloning.
3. Handle CloneNotSupportedException: Handle the CloneNotSupportedException appropriately when cloning an object.
4. Deep cloning when necessary: For complex objects containing reference types, implement deep cloning to ensure that all referenced objects are also cloned.
5. Immutable classes: If possible, design your classes to be immutable to avoid the need for cloning.

Conclusion

Object cloning in Java is a powerful mechanism for creating copies of objects. By understanding the concepts of shallow and deep cloning and implementing the clone() method or Cloneable interface, you can effectively clone objects in your Java applications. However, it’s essential to be cautious while cloning objects, especially when dealing with complex data structures and mutable objects. Following best practices and considering the implications of cloning ensures that your Java applications perform as expected while maintaining the integrity of your data.