Shallow and Deep Copy in Java

[harsha karanam]

Question 1:

Do we need to override the clone method if we implement the Cloneable interface, if there is no specific functionality defined.

If we have to override , what is the benefit of such override.

Question 2:

The below code is from other site (Source:http://javaconceptoftheday.com/difference-between-shallow-copy-vs-deep-copy-in-java/) ,

In the deep copy example

class Course implements Cloneable
{
    String subject1;
    String subject2;
    String subject3;
 
    public Course(String sub1, String sub2, String sub3)
    {
        this.subject1 = sub1;
        this.subject2 = sub2;
        this.subject3 = sub3;
    }
 
    protected Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }
}
 
class Student implements Cloneable
{
    int id;
    String name;
    Course course;

    public Student(int id, String name, Course course)
    {
        this.id = id; 
        this.name = name;
        this.course = course;
    }
 
    //Overriding clone() method to create a deep copy of an object.
    protected Object clone() throws CloneNotSupportedException
    {
        Student student = (Student) super.clone();
        student.course = (Course) course.clone();
        return student;
    }
}
 
public class DeepCopyInJava
{
    public static void main(String[] args)
    {
        Course science = new Course("Physics", "Chemistry", "Biology");
        Student student1 = new Student(111, "John", science);
        Student student2 = null;

        try
        {
            //Creating a clone of student1 and assigning it to student2 
            student2 = (Student) student1.clone();
        }
        catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
 
        //Printing the subject3 of 'student1'
        System.out.println(student1.course.subject3);         //Output : Biology
        //Changing the subject3 of 'student2'
        student2.course.subject3 = "Maths";
        //This change will not be reflected in original student 'student1'
        System.out.println(student1.course.subject3);       //Output : Biology
    }
}

In the deep copy example the clone method definition is modified , even if we don’t override it and have another course object, add it to the student object and use the set method for changing the field , its going to behave the same.

What is the benefit of such override?

Example similar to the above:

Course course=new Course(“subj1″,”subj2”,"subj3");
Student std=new Student(123,“student1”,course);
Student std2=(Student ) std.clone();
Course course2=new Course(“subj1″,”subj2”,"subj3");
std2.setCourse(course2);

is this definition and the overrided clone method definition are the same?