Copy Constructor in Java

Last Updated: 21 September, 2024

In Java, a copy constructor is a special type of constructor that is used to create a new object using an existing object of the same class.

Copy constructor is used if we need to copy a complex object that has many fields or when we need to create a deep copy of an existing object.

Java does not implicitly provide the facility of a copy constructor as in the 'C' language.

Copy Constructor Syntax:

public class Class_Name { // Code // Declaring a copy constructor by passing the parameter as the class public Class_Name (Class_Name refObject) { // Code } }

Copy constructors are one of the strongest features for creating copies of objects in Java. They can be used to create shallow copies or deep copies of objects, depending on our needs.

Advantages of the copy constructor in Java

• A copy constructor is easier if an object is complex and has many fields.
• After creating an object using the copy constructor, we don't need to typecase it.
• The copy constructor allows us to assign values to the final fields.
• If we need to add a field to the class, then we can do so just by changing the input to the constructor.
• It is easier to implement in comparison to the clone() method.
• The copy constructor generates a deep copy of the object.

To create a copy constructor, we simply need to define a constructor that takes an object of the same class as its argument. For example, the following example shows a copy constructor for a class named Student:

Java Copy Constructor Example

class Student { int roll; String student_name; // Parameterized Constructor Student(int rollNo, String stuName) { System.out.println("Parameterized constructor is called."); roll = rollNo; student_name = stuName; } // copy constructor Student(Student student) { System.out.println("Copy constructor is called."); roll = student.roll; student_name = student.student_name; } // Method to return roll number int printRoll() { return roll; } // Method to return student name String printName() { return student_name; } } public class CopyConstructorExample { public static void main(String[] args) { Student student1 = new Student(15, "Shiyanshi Sona"); System.out.println("student1 - Student Roll No. : " + student1.printRoll()); System.out.println("student1 - Student Name : " + student1.printName()); Student student2 = new Student(student1); System.out.println("student2 - Student Roll No. : " + student2.printRoll()); System.out.println("student2 - Student Name : " + student2.printName()); } }

In the above example, to use the copy constructor, we created a new instance of the Student class and passed an existing Student object to the constructor.

After executing the above code, the student2 object will be a copy of the student1 object. This means that the student2 object will have the same student name and roll as the student1 object. However, the student2 object will be a separate object from the student1 object.

See the output of the program after execution.

Output

Parameterized constructor is called.
student1 - Student Roll No. : 15
student1 - Student Name : Shiyanshi Sona
Copy constructor is called.
student2 - Student Roll No. : 15
student2 - Student Name : Shiyanshi Sona

Copy constructor Vs clone() method in Java

The Copy constructor and the Object class's clone() method are both used to create an object from the existing object of the class.

In comparison to the clone() method, the copy constructor is simpler and more efficient for creating a copy of an existing object. Let's take a look at the table below to see how they differ. 

• Unlike the clone() method, the copy constructor does not require us to implement the Clonable interface and handle the CloneNotSupportedException.
• If we use the clone() method, we must typecase the object because it returns a general object reference, whereas the copy constructor returns the original object.
• A final field cannot be assigned a value in the clone() method. It can, however, be assigned to the copy constructor.