Copy Constructor in Java

What is the Use of Java Copy Constructor?

The copy constructor in Java serves various purposes in object-oriented programming. Firstly, it allows developers to create a new object with the same state as an existing object, facilitating the creation of deep copies. This is particularly useful when dealing with complex objects containing nested structures or references to other objects. Additionally, copy constructors enable safe object initialization by ensuring that the new object is independent of the original, preventing unintended side effects from modifications to either instance. Furthermore, copy constructors can be utilized in scenarios such as cloning objects, implementing certain design patterns like Prototype, or facilitating object serialization and deserialization. Overall, the use of copy constructors adds flexibility, reliability, and maintainability to Java codebases by providing a mechanism for creating copies of objects tailored to specific requirements and use cases.

Types of Copy Constructors in Java

In Java, while there’s no built-in keyword for a "copy constructor" like in C++, developers can create custom copy constructors to duplicate an object. These constructors are mainly categorized based on how they copy the data.

1. Shallow Copy Constructor

A shallow copy constructor duplicates the object's field values but does not create copies of the objects referenced by those fields. If the class contains references to other objects, both the original and the copied object will point to the same memory locations for those references.

Example Use Case: Useful when you want a quick clone and don’t mind if both objects share internal references.

2. Deep Copy Constructor

A deep copy constructor not only copies the primitive and immutable fields but also creates new instances for referenced objects. This ensures the original and the new object are entirely independent.

Example Use Case: Ideal when you want a true, independent copy that doesn’t rely on shared references.

Note: Java doesn't provide an automatic copy constructor. Developers must manually define one by passing an object of the same class as a parameter and copying all relevant fields.

Writing a Copy Constructor

Let’s learn more about copy constructors by looking at some examples.

Example of Java Constructor

We develop a parameterized constructor that accepts the values for all instance variables and initialises them with the given values to initialise the values of instance variables of a class.

int brand;
int no;
public Car(String brand, int no){
   this.brand = brand;
   this.no = no;
}

Initialization: 

Car c = new Car(brand, no);

Java Copy Constructor Example

Copy Constructor accept an object of the current class and set the values of instance variables to the values in the obtained object.

public Car(Car c){
   this.brand = c.brand;
   this.no = c.no;
}

Initialization: 

Car copyOfC = new Car(c);

You can also try this code with Online Java Compiler

Run Code

Code Implementation

Let’s see an example program to understand the concept of copy constructor. we have created a car class, which has brand, no class variable. It has parameterised constructor and copy constructor and a display function to display the values.

• Java

Java

import java.util.Scanner;
// class definition
public class Car {
    // variables
    private String brand;
    private int no;
    // normal constructor
    public Car(String brand, int no){
        this.brand = brand;
        this.no = no;
    }
    // copy constructor
    public Car(Car c){
        this.brand = c.brand;
        this.no = c.no;
    }
    // display function
    public void display(){
        System.out.println("brand : "+this.brand);
        System.out.println("no : "+this.no);
    }
    public static void main(String[] args) {
        String brand = "Ford";
        int no = 20;
        Car c = new Car(brand, no);
        System.out.println("Displaying the original object");
        c.display();
        System.out.println("Displaying the copied object");
        Car copyOfC = new Car(c);
        copyOfC.display();
    }
}

You can also try this code with Online Java Compiler

Run Code

Output 

Difference Between Copy Constructor and clone() Method

Advantages of Copy Constructor in Java

• Controlled Copying: Provides developers with control over how objects are copied, allowing for customization according to specific requirements.
• Deep Copy Support: Enables the creation of deep copies, ensuring that nested objects or references are duplicated accurately.
• Safe Object Initialization: Helps in initializing new objects safely by preventing unintended side effects from modifications to the original object.
• Flexibility: Offers flexibility for implementing custom copy behavior, accommodating various scenarios and use cases.
• Efficiency: Generally more efficient than other copying mechanisms due to direct access to object members.

Disadvantages of Copy Constructor in Java

• Manual Implementation: Requires manual implementation within classes, increasing development effort and potential for errors.
• Not Inherited: Copy constructors are not inherited and must be explicitly implemented in each class where copying is required.
• Limited Accessibility: Can only access accessible members of the object, which may limit its usability in certain scenarios.
• No Built-in Cloning Support: Does not have built-in support for object cloning like the clone() method, requiring developers to implement deep copying manually.
• Not Serializable: Objects created using copy constructors are not automatically serializable, requiring additional effort for serialization and deserialization.

Frequently Asked Questions

Example of copy constructor in Java.

An example of a copy constructor in Java is a class Person with a copy constructor Person(Person other) that creates a new Person object by copying the attributes of another Person object.

What is the difference between constructor and copy constructor?

The main difference between a constructor and a copy constructor lies in their purpose: constructors are used to initialize new objects, while copy constructors specifically create new objects by copying the state of existing ones.

Where is the copy constructor used?

Copy constructors are used in scenarios where objects need to be duplicated while maintaining the integrity of their state, such as creating deep copies, implementing cloning mechanisms, or initializing objects based on existing instances.

What is the difference between a shallow copy and a deep copy in the context of a Copy Constructor?

A shallow copy duplicates object references, meaning changes in the original affect the copied object. A deep copy creates independent copies of mutable fields, ensuring modifications in one object don’t impact the other.

What happens if you omit a Copy Constructor in a class with mutable fields?

Without a copy constructor, Java’s default object cloning (via assignment or default copy methods) may cause unintended shared references for mutable fields. This can lead to unintentional modifications, as changes in one object reflect in another, potentially causing unpredictable behavior.

Conclusion

The Copy Constructor in Java plays a crucial role in creating object copies while ensuring data integrity, especially when dealing with mutable fields. Understanding the difference between shallow and deep copies helps prevent unintended side effects in object manipulation. By implementing a well-defined copy constructor, developers can enhance code maintainability, avoid shared reference issues, and ensure object independence where needed.

Recommended Article:

• Understanding Encapsulation in Java
• Duck Number in Java
• Hashcode Method in Java
• Multiple Inheritance in Java
• Fibonacci Series in Java