Java Cloning

I recently watched trailer of "Jurassic World", where scientists are again cloning DNA of thousands years old dinosaur.


Let refresh our memory and see how the word cloning fit into Java world.

What is cloning ?

"In biology, cloning is the process of producing similar populations of genetically identical individuals that occurs in nature when organisms."
-- Wikipedia

Here the term "genetically identical" need attention for Java developers for doing cloning of objects. We will look into the details later.

Java provide a method which help us to create "genetically identical" copy of object. It is achieved through clone() method, which is inside Object class.

Now lets see why Java provide a method to create object. If we create a new object then the state of the object is initialized, but what if we need a current state of object but at the same time we didn't want to disturb the current object.

For Example :- 
Suppose you have an object X which is a singleton object and shared across application. In this scenario suppose a module need an object of X which will be changed the state of the object temporally but this will affect other module also. In this kind of scenario we need a clone of object.  

How to clone an object ? 

We can clone only those classes object which implements the Cloneable interface else it will result into CloneNotSupportedException exception.
Cloneable interface is a markup interface like Serializable interface. Cloneable interface is used to indicate that a class allows a bit wise copy of an object to be made.

Please note clone method does not invoke the constructor of target.


Simple example of Cloning.

Clone.java

1. /**
2. * @Author Anindya Bandopadhyay
3. *
4. * com\ch1\clone\Clone.java
5. *
6. * @Created on Jun 22, 2015 5:49:02 PM
7. */
9. package com.ch1.clone;
11. public class Clone implements Cloneable{
12.  
13.  @Override
14. public Object clone() throws CloneNotSupportedException {
15.    return super .clone();
16. }
17. public Object cloneThis(){
18. Object object = null;
19. try {
20. object = clone();
21. } catch (CloneNotSupportedException e) {
22. e.printStackTrace();
23. }
24. return object;
25. }
26. }

CloneTester.java

1. /**
2. * @Author Anindya Bandopadhyay
3. *
4. * com\ch1\CloneTester.java
5. *
6. * @Created on Jun 22, 2015 10:51:40 AM
7. */
9. package com.ch1.clone;
11. public class CloneTester {
13. public static void main(String[] args) {
14. Clone actual = new Clone();
15. Clone clone = (Clone) actual.cloneThis();
16. System.out.printf("Is both object are same ? %s",(actual == clone));
17. }
19. }

Output of the source code 
Is both object are same ? false

As I earlier mention that we need to pay special attention to "genetically identical". Genetically identical means even if by cloning an object we get a new object but this new object will hold same data and/or object references.

This objects are known as Shallow Copy Object. While using cloning we have to be very careful as this shared object references between actual and clone object.

To mitigate this shared object references we use another technique which is known as Deep Copy Object. In this technique we create new object and copy the values, so that it will not interfere each others object processing.

Just think of the situation where we have a shared I/O object between two objects, where one is trying to writing something into it and another is trying to close it.This kind of situation leads to catastrophe in running environment because of this in Object class clone() method is protected so that if developer cannot simple clone an object. It must be overridden carefully and used by a different public method. 

Lets see how Shallow and Deep copy objects references works.

Shallow Copy Object is achieved by simple invoking super.clone() method.

  

ShallowClone.java

1. /**
2. * @Author Anindya Bandopadhyay
3. *
4. * com\ch1\clone\ShallowClone.java
5. *
6. * @Created on Jun 15, 2015 2:24:22 PM
7. */
9. package com.ch1.clone;
11. public class ShallowClone implements Cloneable {
13. private Object obj1;
14. private int count;
16. public ShallowClone(){
17. obj1 = new Object();
18. count = 1;
19. System.out.println("Default constructor of CloneImpl.");
20. }
22. public ShallowClone(Object obj1,int size){
23. this.obj1 = obj1;
24. this.count = size;
25. System.out.println("CloneImpl(InnerCloneObject obj1,int size) constructor of CloneImpl.");
26. }
28. public Object getObj1() {
29. return obj1;
30. }
32. public void setObj1(Object obj1) {
33. this.obj1 = obj1;
34. }
36. public int getCount() {
37. return count;
38. }
40. public void setCount(int count) {
41. this.count = count;
42. }
46. protected Object clone() throws CloneNotSupportedException{
47. return super.clone();
48. }
50. public ShallowClone cloneThisObject(){
51. ShallowClone object = null;
52. try {
53. System.out.println("\n======================= Start Clone ============================");
54. object = (ShallowClone) clone();
55. System.out.println("======================= End Clone ============================");
56. } catch (CloneNotSupportedException e) {
57. e.printStackTrace();
58. }
59. return object;
60. }
62. }

Deep Copy Object is need to be take care by developer. clone() method is override with respect to specific requirement.

Please note this can be achieve even without overriding the clone() method also. We can simple put the logic directly inside cloneThisObject() method.

DeepClone.java

1. /**
2. * @Author Anindya Bandopadhyay
3. *
4. * com\ch1\clone\DeepClone.java
5. *
6. * @Created on Jun 19, 2015 12:12:26 AM
7. */
9. package com.ch1.clone;
11. public class DeepClone implements Cloneable {
13. private String name;
14. private Object obj1;
16. public DeepClone(){
17. name = "Andy";
18. obj1 = new Object();
19. System.out.println("Default constructor of InnerCloneObject.");
20. }
22. public DeepClone(String name,Object obj1){
23. this.name = name;
24. this.obj1 = obj1;
25. System.out.println("InnerCloneObject(String name,Object obj1) constructor of InnerCloneObject.");
26. }
28. public String getName() {
29. return name;
30. }
32. public void setName(String name) {
33. this.name = name;
34. }
36. public Object getObj1() {
37. return obj1;
38. }
40. public void setObj1(Object obj1) {
41. this.obj1 = obj1;
42. }
44. protected Object clone() throws CloneNotSupportedException{
45. // Customize clone logic is placed.
46. System.out.println("\n======================= Start Clone ============================");
47. DeepClone object = new DeepClone();
48. System.out.println("======================= End Clone ============================");
49. return object;
50. }
52. public DeepClone cloneThisObject(){
53. DeepClone object = null;
54. try {
55. object = (DeepClone) clone();
56. } catch (CloneNotSupportedException e) {
57. e.printStackTrace();
58. }
59. return object;
60. }
62. }

Lets upgrade CloneTester class for Shallow and Deep copy objects.

CloneTester.java

1. /**
2. * @Author Anindya Bandopadhyay
3. *
4. * Chapter1\com\ch1\CloneTester.java
5. *
6. * @Created on Jun 22, 2015 10:51:40 AM
7. */
9. package com.ch1.clone;
11. public class CloneTester {
13. public static void main(String[] args) {
14. ShallowClone shallowActualObject = new ShallowClone();
15. DeepClone deepActualObject = new DeepClone();
17. ShallowClone shallowCloneObject = shallowActualObject.cloneThisObject();
18. DeepClone deepCloneObject = deepActualObject.cloneThisObject();
20. System.out.printf("Is ShallowClone actual object are different from clone object ? %s ",
21. (shallowActualObject != shallowCloneObject));
23. System.out.printf("\nIs object inside ShallowClone object are different ? %s \n",
24. (shallowActualObject.getObj1() == shallowCloneObject.getObj1()));
26. System.out.printf("Is DeepClone actual object are different from clone object ? %s ",
27. (deepActualObject != deepCloneObject));
29. System.out.printf("\nIs object inside DeepClone object are different ? %s ",
30. (deepActualObject.getObj1() == deepCloneObject.getObj1()));
32. }
34. } 

Output of the source code 
Default constructor of ShallowClone.
Default constructor of DeepClone.

======================= Start Clone ============================
======================= End Clone   ============================

======================= Start Clone ============================
Default constructor of DeepClone.
======================= End Clone   ============================
Is ShallowClone actual object are different from clone object ? true
Is object inside ShallowClone object are different ? true
Is DeepClone actual object are different from clone object ? true
Is object inside DeepClone object are different ? false

Shallow Copy Object Graph

Shallow Copy Object

Deep Copy Object Graph

Deep Copy Object

Just compare the outputs and object graphs. By these we can deceive that how important for developer to pay attention to need of cloning or overriding the clone() method.

If you have any question or feedback please comment.