Does Java have a default copy constructor (like in C++)? [duplicate]

Question

Does Java has a default copy constructor as C++? If it has one - does it remain usable if I declare another constructor (not a copy constructor) explicitly?

Bruin

By a copy constructor, do you mean a constructor that accepts an object of the same type, and duplicates it? If yes - then no, java doesn't have that. – Grudge

No it doesn't have a default copy constructor. – Hutchens

#828285 – Grudge

Answer 1

Java does not have bulit-in copy constructors.

But you can write your own such constructors. See an example below:

class C{
    private String field;
    private int anotherField;
    private D d;

    public C(){}

    public C(C other){
        this.field = other.field;
        this.anotherField = other.anotherField;
        this.d = new D(other.d); //watch out when copying mutable objects; they should provide copy constructors, as well. Otherwise, a deep copy may not be possible
    }

    //getters and setters
}

class D{//mutable class

    //fields
    public D(D other){
        //this is a copy constructor, like the one for C class
    }
}

Volcanic

@RomanVottner To expand, this is not always simple, especially if you cannot change one of the fields that are mutable to give it a copy constructor. – Grudge

Answer 2

Java does not have a default copy constructor. You'll need to define it yourself.

Flapper

Answer 3

No, it doesn't have a default copy constructor. A default constructor.

You don't have to provide any constructors for your class, but you must be careful when doing this. The compiler automatically provides a no-argument, default constructor for any class without constructors. This default constructor will call the no-argument constructor of the superclass. In this situation, the compiler will complain if the superclass doesn't have a no-argument constructor so you must verify that it does. If your class has no explicit superclass, then it has an implicit superclass of Object, which does have a no-argument constructor.

Usually I provide a one like,

public class CopyConEx {

      /**
      * Regular constructor.
      */
      public CopyConEx(type  field1, type field2) {
        this.field1 = field1;
        this.field2 = field2;
      }

      /**
      * Copy constructor.
      */
      public CopyConEx(CopyConEx aCopyConEx) {
        this(aCopyConEx.getField1(), aCopyConEx.getField2());   

      }

Balkan

Answer 4

There is a copy constructor (But not default one), but it should be called explicitly (In C++ it'll be implicitly called when needed):

public MyClass(MyClass toCopy) { 
   someField = toCopy.someField; 
}

Peckham

That's not default. You have to define it yourself. – Family

That's what I meant.. – Peckham

Answer 5

Java support cloning but not using copy constructor. Please find below url on Java cloning.

http://adtmag.com/articles/2000/01/18/effective-javaeffective-cloning.aspx

Perceive

If you read any of the other answers, you'll find that of course Java supports copy constructors. They're just not there by default, any more than clone() is supported by default (you have to implement Cloneable and define clone() yourself). (And your article is nearly 14 years old... not sure I'd still trust something written in the days of Java 1.2.) – Family

Answer 6

In Java the provision of an automatic copy constructor would be pointless.

Java doesn't need one since you can only have references to objects. (In C++ you can pass objects round by value so the grammar needs to allow for an automatic object copy).

If you need to take deep copies of object in Java, then implement Cloneable.

Wohlen

Answer 7

Like C++, Java also supports copy constructor. But, unlike C++, Java doesn’t create a default copy constructor if you don’t write your own.

Also see write a Copy Constructor using Deep copy.

Cumulonimbus

just to add java doesn't create a default copy coz there isn't much need for it in normal situations. It's only pass by reference in java. – Blaze