Why doesn't Java have a copy constructor?

Why doesn't Java support a copy constructor like in C++?

Java does. They're just not called implicitly like they are in C++ and I suspect that's your real question.

Firstly, a copy constructor is nothing more than:

public class Blah {
  private int foo;

  public Blah() { } // public no-args constructor
  public Blah(Blah b) { foo = b.foo; }  // copy constructor
}

Now C++ will implicitly call the copy constructor with a statement like this:

Blah b2 = b1;

Cloning/copying in that instance simply makes no sense in Java because all b1 and b2 are references and not value objects like they are in C++. In C++ that statement makes a copy of the object's state. In Java it simply copies the reference. The object's state is not copied so implicitly calling the copy constructor makes no sense.

And that's all there is to it really.

From Bruce Eckel:

> Why does [a copy constructor] work in C++ and not Java? > > The copy constructor is a fundamental > part of C++, since it automatically > makes a local copy of an object. Yet > the example above proves that it does > not work for Java. Why? In Java > everything that we manipulate is a > handle, while in C++ you can have > handle-like entities and you can also > pass around the objects directly. > That’s what the C++ copy constructor > is for: when you want to take an > object and pass it in by value, thus > duplicating the object. So it works > fine in C++, but you should keep in > mind that this scheme fails in Java, > so don’t use it.

(I recommend reading the entire page -- actually, start here instead.)

I think the answer to this is very interesting.

For one, I believe that in Java all objects are on the heap, and while you don't have pointers, you do have "References". References have copy symantics and java internally keeps track of reference counts so that its garbage collector knows whats safe to get rid of.

Since you only access objects through copyable references, the actual number of times you need to copy an object is greatly reduced (for example, in C++ just passing an object to a function (by value) results in new objects being copy constructed, in Java only the reference to the object is passed). The designers probably figured that clone() would be enough for the remaining uses.

This is just my opinion (I am sure there is a justifiable answer)

Copy constructors in C++ are primarily useful when you are sending or returning instances of classes by value, since that is when the copy constructor is transparently activated.

Since in Java everything is returned by reference, and the VM is geared towards dynamic allocation, there really wasn't a justification for the complexities of a copy constructor.

In addition, since everything is by reference, a developer would often have to provide their own implementation and decision on how to clone fields.

Guess they figured you can just make a clone() method instead?

It kind of does. When shallow copies are okay you have [clone()](http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Object.html#clone(\)) and when they aren't you have to implement a deep copy just like C++.

The only substantive difference is that it's a factory method rather than a constructor proper, but in terms of flexibility and testability that's probably a good thing.

I'm not much of a C++ programmer, but I do seem to remember a rule about the "three amigos" - copy constructor, assignment operator, and destructor. If you have one, then you likely need all three.

So maybe without a destructor in the language, they didn't want to include a copy constructor? Just a guess.

Well, it can. It just doesn't get created implicitly. If I had to guess, it's probably related to the fact that Java objects are always heap-allocated.

In C++, the default copy constructor is a member-wise shallow copy. If a class owns memory allocated on the heap (via a raw pointer), this will cause the copy to share internals with the original, which is not what you want.

Imagine for a moment that Java had this behavior. Any class that has fields that are objects (read: essentially all of them) would have the wrong behavior, and you'd need to override it yourself. For 99% of cases, you haven't saved anyone any trouble. Further, you've just created a subtle trap for yourself - imagine you accidentally forget to override the default copy constructor. If it was generated by default, and you try to use it, the compiler won't complain at all, but your program will misbehave at runtime.

Even if they made a default copy constructor that performs a deep copy, I'm not sure that would be particularly useful. Not only do you tend to perform fewer copies in Java than C++ anyway, but you don't always want to deep copy a field.

Objects that you just own, and objects that you hold references to because you need them, but aren't responsible for, are the same - just fields. Ownership and borrowing are not first class concepts. For objects you own, you'd want to deep copy them (unless they're immutable, in which case you shouldn't bother), and for objects you just hold a reference to, you want to copy the reference.

I would argue that a copy constructor that just mindlessly deep-copies everything wouldn't be suitable for many classes, either. Certainly more than shallow-copying by default, though.

Java have copy Constructor
Note:Instead of demo d2=new demo(d1) ,you can write demo d2=d1
Main difference b/w two
demo d2=new demo(d1) means new object is created and it is allocated memory But
demo d2=d1 implies only reference variable is created which uses the same memory address of object d1 and hence d2 not allocated seperated memory.

Syntax of copy constructor:
See below Example first Copy constructor is very easy :))
classname(int datafield) //Simple Constructor
{
this.datafield=datafield;
}

classname(classname object)
{
datafield=object.datafield;//See below example
}
Now for Calling
{

class demo
{
private int length;
private int breadth;

private int radius;

demo(int x,int y)

{
	length=x;
	breadth=y;
}
int area()
{
	return length*breadth;
}

//Copy Constructor
demo(demo obj)
{
	length=obj.length;
	breadth=obj.breadth;
}


public static void main(String args[])
{
	demo d1=new demo(5,6);
	demo d2=new demo(d1);//Invokes Copy Constructure
	System.out.println("Area for d1 object="+d1.area());
	System.out.println("Area for d2 object="+d2.area());
	
}

}