Why do we need copy constructor and when should we use copy constructor in java

I was going through Copy Constructors, I have gone through the links in stack over flow and others as well. But i am not clear on the following points.

1. Why do we need a Copy Constructor
2. When do we need a Copy Constructor

I mean what is the exact situation or scenario we would need to use Copy Constructor. Can some one explain with an example or point out links so that i can go through and understand them in clear.

Following are the links i have gone through to get an understanding of what is a copy constructor.

http://www.programmerinterview.com/index.php/java-questions/how-copy-constructors-work/

https://deepeshdarshan.wordpress.com/2013/12/05/copy-constructors-in-java/

The second link explains 'why' and 'where' the copy constructor is to be used. But still i am not clear on it.

Below is my class Employee.java

package com.test;

/**
 * @author avinashd
 *
 */
public class Employee {

    private String rollNo;
    private String name;

    //constructor
    public Employee(String rollNo, String name){

        this.rollNo = rollNo;
        this.name = name;
    }

    //copy constructor
    public Employee(Employee employee){

    this.rollNo = employee.rollNo;
    this.name = employee.name;

    }

    public String getRollNo() {
        return rollNo;
    }

    public void setRollNo(String rollNo) {
        this.rollNo = rollNo;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Copy Constructor is used to create and exact copy of an object with the same values of an existing object.

Say for example we have an Employee with values as rollNo: 1 and name: avinash. Copy Constructor would create a similar object with values as rollNo: 1 and name: avinash . But both are 2 different objects and changes to the values of on object will not affect another object.

The Question here is

When we have a constructor such as

public Employee(String rollNo, String name){
    this.rollNo = rollNo;
    this.name = name;
}

to create an object. We can call the same constructor to create another object. But why do we need to call copy constructor.When do we need to call it ?. Please explain

Solution 1:

There are 2 good reasons for using a copy constructor instead of the constructor passing all parameters :

1. when you have a complex object with many attributes it is much simpler to use the copy constructor
2. if you add an attribute to your class, you just change the copy constructor to take this new attribute into account instead of changing every occurence of the other constructor

Solution 2:

Copy constructors, by convention, should provide a deep copy of objects. As already mentioned by other answers, the main convenience provided by copy constructors is when your object becomes too complex. Note that java.lang.Cloneable provides an (almost) similar declaration.

But there are a number of advantages to using copy constructors over the Cloneable interface.

1. Cloneable as an interface does not actually provide any methods. For it to be effective, you still need to override the clone method of java.lang.Object. This is quite a counterintuitive use for an interface.

2. clone returns an Object. For it to be of any use, you still need to typecast. This is awkward and could lead to runtime errors.

3. The clone method is poorly documented. For clone, things can get messed up if you have final fields pointing to mutable objects.

4. Most importantly, copy constructors can take in and deep copy instances of subclasses. IMO, this is where copy constructors really shine.

There are more advantages (see Joshua Bloch's Effective Java 2e) but these are the points which I have found most pertinent to what I have worked on so far.

[1] Nothing in the Java language actually provides a default construct for deep copying. At most, objects can just tell programmers that they can be deep copied by, say, implementing Cloneable or providing a copy constructor.