Java Clone, Shallow Copy and Deep Copy

28/09/2009

Clone (κλών) is a Greek word meaning “branch”, referring to the process whereby a new plant can be created from a twig. In biology it is about copying the DNAs. In real world, if you clone Marilyn Monroe, will you get a copy of her with same beauty and characteristics? No, you will not get! This exactly applies to java also. See how java guys are good at naming technologies.

Marilyn-Monroe

In java, though clone is ‘intended’ to produce a copy of the same object it is not guaranteed. Clone comes with lots of its and buts. So my first advice is to not depend on clones. If you want to provide a handle / method to deliver a copy of the current instance write a kind of factory method and provide it with a good documentation. When you are in a situation to use a third party component and produce copies of it using the clone method, then investigate that implementation carefully and get to know what is underlying. Because when you ask for a rabbit, it may give monkeys!

Shallow Copy

Generally clone method of an object, creates a new instance of the same class and copies all the fields to the new instance and returns it. This is nothing but shallow copy. Object class provides a clone method and provides support for the shallow copy. It returns ‘Object’ as type and you need to explicitly cast back to your original object.

Since the Object class has the clone method (protected) you cannot use it in all your classes. The class which you want to be cloned should implement clone method and overwrite it. It should provide its own meaning for copy or to the least it should invoke the super.clone(). Also you have to implement Cloneable marker interface or else you will get CloneNotSupportedException. When you invoke the super.clone() then you are dependent on the Object class’s implementation and what you get is a shallow copy.

Deep Copy

When you need a deep copy then you need to implement it yourself. When the copied object contains some other object its references are copied recursively in deep copy. When you implement deep copy be careful as you might fall for cyclic dependencies. If you don’t want to implement deep copy yourselves then you can go for serialization. It does implements deep copy implicitly and gracefully handling cyclic dependencies.

Ads by Google

One more disadvantage with this clone system is that, most of the interface / abstract class writers in java forget to put a public clone method. For example you can take List. So when you want to clone their implementations you have to ignore the abstract type and use actual implementations like ArrayList by name. This completely removes the advantage and goodness of abstractness.

When implementing a singleton pattern, if its superclass implements a public clone() method, to prevent your subclass from using this class’s clone() method to obtain a copy overwrite it and throw an exception of type  CloneNotSupportedException.

Note that clone is not for instantiation and initialization. It should not be synonymously used as creating a new object. Because the constructor of the cloned objects may never get invoked in the process. It is about copying the object in discussion and not creating new. It completely depends on the clone implementation. One more disadvantage (what to do there are so many), clone prevents the use of final fields. We have to find roundabout ways to copy the final fields into the copied object.

Clone is an agreement between you, compiler and implementer. If you are confident that you all three have good knowledge of java, then go ahead and use clone. If you have a slightest of doubt better copy the object manually.

Example source code for java clone and shallow copy

class Employee implements Cloneable {

 private String name;
 private String designation;

 public Employee() {
 this.setDesignation("Programmer");
 }
 public String getDesignation() {
 return designation;
 }

 public void setDesignation(String designation) {
 this.designation = designation;
 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public Object clone() throws CloneNotSupportedException {
 /*
 Employee copyObj = new Employee();
 copyObj.setDesignation(this.designation);
 copyObj.setName(this.name);
 return copyObj;
 */
 return super.clone();
 }
}

public class CloneExample {
 public static void main(String arg[]){
 Employee jwz = new Employee();
 jwz.setName("Jamie Zawinski");
 try {
 Employee joel = (Employee) jwz.clone();
 System.out.println(joel.getName());
 System.out.println(joel.getDesignation());
 } catch (CloneNotSupportedException cnse) {
 System.out.println("Cloneable should be implemented. " + cnse );
 }
 }
}

Output of the above program:

Jamie Zawinski
Programmer
This Core Java tutorial was posted on 28/09/2009.
Ads by Google

89 comments on “Java Clone, Shallow Copy and Deep Copy

  1. Great work Joe! Your are nicely mixing technology and humor. Its an interesting read.

  2. In your example source code, why is a block of code commented? Any particular meaning for that? It will help if you add a comment!

  3. Commented part does the same work done by super.clone() – just to showcase that I have added that in comment.

  4. Pingback: Java Serialization

  5. what is the difference between the above code and this code
    Employee joel = jwz;
    System.out.println(joel.getName());
    System.out.println(joel.getDesignation());

    Both give the same output.

  6. Som, you have not cloned the object. That is you have not acquired a copy of the object. Instead you have assigned the reference of that object to a new variable. Eventually pointing to same memory location. Therefore you get the same output!

    In my code I get the same output because java clone not only copies object meta data, it also copies value of attributes.

    I suggest you an experiment! Add one more attribute to Employee class. After clone set a value to original object’s attribute. Now print new object’s attribute and see if that value is reflected. Do this in my code and then in your code. This will help to clear your doubt on java clone, shallow copy and deep copy.

  7. That was a valuable suggestion Joe. Thank you so much. I have another doubt. Can you please list some applications of shadow and deep copy or where they might be used?

  8. Application of shallow copy or deep copy depends on business needs. Unless your business logic explicitly needs deep copy, you can always go for shallow copy.

    • what is difference between shallow copy and deep copy.. joe?

  9. useful article and thanks for posting it
    Can you give an example for this “When implementing a singleton pattern, if its superclass implements a public clone() method, to prevent your subclass from using this class’s clone() method to obtain a copy overwrite it and throw a CloneNotSupportedException.”

    • Manoj,

      In your singleton class, overwrite the clone method, something like this

      public Object clone(){
      throw CloneNotSupportedException();
      }

      • its override & not overwrite *** apologies…

  10. three disadvantage given is cool…

    Dipanshu

  11. Nice, but it wasn’t too hard to notice that you name-dropped Jamie Zawinski in your source code (right down to using his usual Internet handle, jwz, as a variable name). Now, it’s possible you wrote this code all on your own and you thought it would be cheeky fun to name-drop someone who’s a co-founder of both Netscape and Mozilla.org, but based on my experiences, I find it more likely that the code was plagiarized from someone else’s example.

    This makes me wonder what else was plagiarized, if the example code looks suspect. Again, maybe I’m wrong, but I’m just saying what it looks like to me. I’ve seen a lot of tech blogs and websites out there that recycle other people’s content as their own, often without even giving proper attribution (and in some cases charging for access to content that isn’t theirs in the first place!).

    Now, if you *did* write that code… well, I hope JWZ isn’t a litigious sort of person. It’s kind of considered bad form to drop someone else’s name in sample code, unless you have a close relationship with that person and/or you have some kind of rivalry with them.

    Now, as to your article’s contents…

    “When implementing a singleton pattern, if its superclass implements a public clone() method, to prevent your subclass from using this class’s clone() method to obtain a copy overwrite it and throw a CloneNotSupportedException.”

    The word here is override, not overwrite. Big difference in semantics.

    “One more disadvantage with this clone system is that, most of the interface / abstract class writers in java forget to put a public clone method.”

    They didn’t “forget” to do it. The clone method belongs to the Object class, and must be overridden. Abstract classes will have this method inherited from Object, but it’s a protected method, and the abstract class — by definition — won’t have all details implemented that a concrete subclass has. The point is, an abstract superclass would need to know implementation details of concrete subclasses, which is a big no-no, just in order to implement clone(). Better to defer that implementation to the concrete subclass, which may possess fields and other methods not present in the abstract superclass.

    By the same token, it should now be obvious why an interface can not contain clone() as a method — first, there is already a protected clone() method in Object which you must override, and secondly, the Cloneable interface is what marks an object as being capable of being cloned, but an interface (the hypothetical interface we’re talking about, not the Cloneable interface) can’t make guarantees about the implementation logic of classes that implement it. The implementing class still needs to override Object.clone() no matter what.

  12. I found the above text on this page: //interviewboard.wordpress.com/page/3/

    Someone is plagiarising. Thanks for that, otherwise I would not find this information. :)

  13. Joe, Nice explanation about cloning.
    It would have been nice, if you had given example of deep cloning as well.

  14. Not only this concept every topic on this site is too good.

  15. hey can any1 tell me how can we print the value of PI in java without using Math class i.e. without using Math.PI…???

  16. hey can u plz tel me how can we print d value of PI without using Math class i.e. without using Math.PI…???

  17. this example is so nice and managed environment. pls helps for these line we r also java developer. thanks

  18. Pingback: Java String

  19. what exactly is the difference between shallow cloning and deep cloning?

  20. The cloning concept is clearly, to the point explained. Great work!! Thanks!!

  21. First of all I wants to say thanks for so good explanation.

  22. Thanks for the detailed one on clone. Where cloning (shallow or deep) is used ? Any one practical situation or business need demanding cloning ? Please give situation.

    Very much thanks for yours Java Blogs.

    Thanks,
    Shrikanth

  23. It would be helpful if you provide example of deep cloning

  24. Can I create singleton class as a clonable??
    If we create clone of singleton class then what is the purpose of class to make a singleton.

  25. Very good description joe. From the above article, i can say cloning is use for making a clone object. Can you please tell me the scenario where java is actually using cloning concept.Please give some example also.

    Regards,
    Ashok

  26. I dont understand the difference of shallow and deep copy. If we copy your code and implement the deep copy clone then output will be the same. We need to add one object reference to the Employee object then we can understand the difference.

  27. Really its great topic ….
    U explained nicely…. thanks a lot.
    Thanks
    manoj CITE

  28. hi please give one example of deep copy…
    it would be better

  29. Deep clone : You will have to override the clone method in each of the classes that the class to be cloned is composed of.
    The below example is just to illustrate the deep clone.

    package clone;

    public class Customer implements Cloneable{

    String name;
    Order order;
    public Customer(String name, Order order) {
    super();
    this.name = name;
    this.order = order;
    }

    public Order getOrder() {
    return order;
    }

    public void setOrder(Order order) {
    this.order = order;
    }

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }

    public Customer() {
    super();
    // TODO Auto-generated constructor stub
    }

    public Customer(String name) {
    super();
    this.name = name;
    }

    @Override
    public Object clone(){
    try {
    Customer clonedCustomer = (Customer)super.clone();
    clonedCustomer.setOrder((Order)order.clone());
    return clonedCustomer;
    } catch (CloneNotSupportedException e) {
    e.printStackTrace();
    }
    return null;
    }

    }

    package clone;

    public class Order implements Cloneable {

    Item item;

    public Order(Item item) {
    super();
    this.item = item;
    }

    public Item getItem() {
    return item;
    }

    public void setItem(Item item) {
    this.item = item;
    }

    @Override
    public Object clone(){
    try {
    Order clonedOrder = (Order)super.clone();
    clonedOrder.setItem((Item)item.clone());
    return clonedOrder;

    } catch (CloneNotSupportedException e) {
    e.printStackTrace();
    }
    return null;
    }

    }

    package clone;

    public class Item implements Cloneable {

    String itemName;

    public Item(String itemName) {
    super();
    this.itemName = itemName;
    }

    public String getItemName() {
    return itemName;
    }

    public void setItemName(String itemName) {
    this.itemName = itemName;
    }
    @Override
    public Object clone(){
    try {
    return super.clone();
    } catch (CloneNotSupportedException e) {
    e.printStackTrace();
    }
    return null;
    }
    }

    package clone;

    public class ShallowCloneTest {

    /**
    * @param args
    */
    public static void main(String[] args) {
    Customer cust = new Customer(“Cust001″, new Order(new Item(“Item001″)));
    System.out.println(“original object :” + cust);
    Customer cloned = (Customer)cust.clone();
    System.out.println(“cloned object :” + cloned);
    cloned.getOrder().getItem().setItemName(“Item002″);
    cloned.setName(“Cust002″);
    System.out.println(“original object :” + cust.getOrder().getItem().getItemName());
    System.out.println(“original object :”+ cust.getName());
    }

    }

  30. Hi Joe,

    According to you and javadoc Object class clone method provides a shallow copy.

    Shallow copy is the copy which shares the same memory location. but in case of clone java creates a new object(seperate memory location) and copies all the properties of the actual object to new object. I am really very confused.

    http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html#clone%28%29

    if you see this link it clearly says that clone creates shallow copy and a new object with copied properties

    but if you see this link

    http://en.wikipedia.org/wiki/Object_copy

    it says that shallow copy shares same memory location and change in one object can change state of copied object

    but when i used cloned object and changed value of actual object it did not had any impact on cloned object

    Please help…

    • In case of Shallow clone, if the primitives are copied and reference variable except String(as immutable) are reused in cloned object. So if we modify primitive values in one object,it does not reflect in another object but if we modify reference vlues in cloned object, same value also available in original object.
      From this we sure that primitives are copied and reference variable(not String) are shared or reused in cloned object.

  31. Hi Joe
    whatever Anonymous tells is valid point , even I am also getting confused to understarnd differences between deep and shallow clones , Please still more clear
    in memory locations perspective,
    but whaterver disadvantages explained are very good

  32. Can someone explain the statement with some example which says “clone prevents the use of final fields.”
    But cloned object retains the value of final fields also along with other member variables.

  33. really this site gives a perfect answer … i like it..

  34. awesome explanation….useful…i added the site to my favourites :)

    anjana..

  35. Sameer

    clone() comes with default constructor which doesn’t have any arguments in that case its impossible to initialize final variables.

  36. ==========================================
    Since the Object class has the clone method (protected) you cannot use it in all your classes
    ==========================================

    Can you give example of a class where clone() can’t be used.
    Since Object is the super class of all java classes clone should be supported by all classes.

  37. Well.. perfect explanation.. Thank you…

  38. rocking joe, this blog will help us to become masters in java…

  39. Hi Joe,

    Hope you are doing good.

    I am referring to the statement “Clone comes with lots of its and buts.”

    In that perhaps its is ifs ? If Yes then it can be corrected :)

    Thanks for this Cloning stuffs.

    Regards
    Navin

  40. I have a query regarding limitation of Final.
    I am using JDK7 and used parameter as below.
    private final String imFinal;
    which is initialized in constructor as
    this.imFinal = “I am final”;
    Now after cloning this object, I can print value of final parameter using cloned object.
    So it looks like there is no limitation on Final. Please clarify.

  41. hello sir ::::

    i want to jdbc concept in driver .how to create in 4 drivers and setting.in simple way

    plz send my mail

  42. Just visited the page Rob pointed out :
    //interviewboard.wordpress.com/page/3/

    however, it contains hyperlinks to your blog.

    Wanted to verify if the work was plagiarized but {THANK GOD} was good to learn it’s not!

    I have been referring to various blogs of yours, thank you for your work.

    #Respect

  43. I have a doubt a)Object class has clone method,b)Implicitly all classes extends Object class.Then why is it neccessary to implement Clonable interface.

    • Cloneable interface is a marker interface having no method. The class which implement this interface get special status so that JVM can mark this class will be cloned.

  44. Pingback: Java Array

  45. Pingback: Prototype Design Pattern

  46. I like the comment “Because when you ask for a rabbit, it may g”"”ive monkeys!”

  47. Thanks a lot! You make a complex concept very simple.

  48. How clone prevent use of final field

  49. When implementing a singleton pattern
    if its superclass implements a public clone() method,
    to prevent our subclass from using this class’s clone() method to obtain a copy
    while overwrite clone method, Do we need to throw an exception of type CloneNotSupportedException?

    I feel if we class same static getInstance() factory method will server the purpose.

    Please correct me if my understanding is wrong.

  50. /*
    Employee copyObj = new Employee();
    copyObj.setDesignation(this.designation);
    copyObj.setName(this.name);
    return copyObj;
    */
    clone method does not call constructor. in the above code the first line is calling the default constructor. then how will the above code is equivalent to super.clone()? can u pls explain if i am wrong.

  51. Joey,I was experimenting with your code.
    What I found that we need not to override clone method. Only implementing Cloneable interface.Then calling obj.clone will work.
    Is there any particular reason why we should override this method?

    • Joey, Cloneable interface is a marker interface and it doesnt have any methods it is just to intimate the compiler that this class is eligible for creating clone object. Even clone() is ‘Object’ class method and ‘Object’ class is super class in Class heirarchy we cannot override clone method directly it will throw CloneNotSupportedException, the main reason is to avoid making every class as Cloneable.

      • Sorry for typo, my previous post is for Anil.

  52. Good Work..
    Good Example
    & Good Explanation..:)

  53. super example sir, the way you explain is very nice, it gives me visual representation of how the flow goes, thanks lot

  54. if i add some static field like age.if we using the commented section then update it in using clone object not updated in its main object.

  55. Hi joe,

    I was reding this article to understand the ways to deep copy an object “Java Clone, Shallow Copy and Deep Copy”

    Unfortuntely in this article there is no single way mentioned to deep copy an object. Can you include at least one implementation for that here?

    It will also clear a lot of questions like what is the difference between Deep Copy and Shallow Copy.

    Thanks,
    Swapnil

  56. Hi Joe,
    I have edited the code that you had given,
    still I am getting the same output,
    in that case can you please explain how cloning really works.

    class Employee{
    private String name;
    private String designation;

    public Employee() {
    this.setDesignation(“Programmer”);
    }
    public String getDesignation() {
    return designation;
    }

    public void setDesignation(String designation) {
    this.designation = designation;
    }

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }
    }

    public class ShallowCopy {
    public static void main(String arg[]){
    Employee employee = new Employee();
    employee.setName(“Uvaraj”);
    //employee.setDesignation(“Senior Developer”);
    try {
    System.out.println(employee.getName());
    System.out.println(employee.getDesignation());
    } catch (Exception e) { System.out.println(“Cloneable should be implemented. ” + cns);
    }
    }
    }

  57. A very good explanation on the topic. Thanks Joe.

  58. you have mentioned that cloning not invoke the constructor. but your code in clone method
    public Object clone() throws CloneNotSupportedException {
    /*
    Employee copyObj = new Employee();
    copyObj.setDesignation(this.designation);
    copyObj.setName(this.name);
    return copyObj;
    */
    return super.clone();
    }
    invoke the constructor.

    both statements are totally different.
    Do you have any comment.

  59. Bass. Please tell us any one real time scenario using with clone

  60. I’m afraid I don’t understand this: “Since the Object class has the clone method (protected) you cannot use it in all your classes.”

    I thought a protected method was supposed to be accessible in all subclasses of the class that defines it.

Leave a Reply

Your email address will not be published.

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>