Java Clone, Shallow Copy and Deep Copy

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

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!

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.

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?

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.”

three disadvantage given is cool…

Dipanshu

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.

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. :)

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

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

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…???

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

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

well explained sir thanks

Very Nice Explained….
Thanks Sir.

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

Excellent article, Great job

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

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

Could you provide code for deep copy, if u can ? Thanks

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

It is nice !

Liked the head first style

It would be helpful if you provide example of deep cloning

Nice article

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.

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

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.

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

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

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());
}

}

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…

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