Java Clone() concept | how clone work in java | java clone interivew question answer

First of all Java clone() method has given in Object class with below
protected Object clone() throws CloneNotSupportedException

with above definition some time in interview question you will found like
  • Why clone() method has given in Object class
  • What is the reason behind to make clone() method protected
  • What meaning of CloneNotSupportExeption
  • What is Shallow cloning and deep cloning

Definition
Clone() method is used to create a copy of an object of a class which implements Cloneable interface. By default it does field-by-field copy as the Object class doesn't have any idea in advance about the members of the particular class whose objects call this method. So, if the class has only primitive data type members then a completely new copy of the object will be created and the reference to the new object copy will be returned. But, if the class contains members of any class type then only the object references to those members are copied and hence the member references in both the original object as well as the cloned object refer to the same object.

Use of Cloneable interface
 
We get CloneNotSupportedException if we try to call the clone() method on an object of a class which doesn't implement the Cloneable interface. This interface is a marker interface and the implementation of this interface simply indicates that the Object.clone() method can be called on the objects of the implementing class.

Java clone() concept


1. Objects in Java are referred using reference types, and there is no direct way to copy the contents of an object into a new object.  The assignment of one reference to another merely creates another reference to the same object.
2.  When you don't want to modify the method caller's (or original) object.
 Different analysis on same set of data in an Object. Rather than fetching the data again and again, populate object once and clone it for a new analysis.
 Games - walls, doors, cars graphics - clone the object, change the params.
3.For any class to able to be cloned .clone() - it MUST implement java.lang.Cloneable interface. Otherwise is .clone is used, it throws java.lang.CloneNotSupportedException at runtime.
  It is a marker interface - which simply tells JVM that the Object.clone() method can be called on the objects of this or sub classes.
4. Shallow Copy - see clone() method in below code
 This is a result of the default cloning functionality provided by the Object.clone()
 When this is used, it copies the primitives and the references. Only references are copied to new cloned Object. Actual referenced object remains as it. That means, the member references in original and cloned object - point to same object.
 
5.  Deep Copy - see deepClone() method in below code
 Copy the actual member objects along with primitives and member references.
 We need to override the clone() method in order to achieve it. But need to make sure that member Objects that we are trying to copy, should also implement Cloneable, only then then can be cloned.
 
 
public class Clones {
public static void main(String[] args) throws CloneNotSupportedException {
Person p1 = new Person("AAA", 123, 100, 200);
System.out.println("Original");
System.out.println(p1.salary.basic);
Person p2 = (Person) p1.deepClone();
//p2.name = "BBB";
//p2.salary.basic = 2222;
System.out.println(p1.equals(p2));
System.out.println("Clone");
System.out.println(p2.salary.basic);
System.out.println("Original");
System.out.println(p1.salary.basic);
}
}
// cloneable class implements Cloneable
class Person implements Cloneable {
public String name = null;
public int id = 0;
public Salary salary = null;
public Person(String name, int id, int basicSal, int bonusSal) {
this.name = name;
this.id = id;
// using Object type member to test for cloning
Salary sal = new Salary();
sal.basic = basicSal;
sal.bonus = bonusSal;
this.salary = sal;
}
// shallow copying
protected Object clone() throws CloneNotSupportedException {
// This is default cloning provided by the Object.clone()
return super.clone();
}
// deep copying
protected Object deepClone() throws CloneNotSupportedException {
// The clone() method produces an Object, which must be recast to the proper type
Person p = (Person) super.clone();
// In deep cloning, we also clone the member objects, but for this to work - //member objects should be Cloneable
p.salary = (Salary) p.salary.clone();
return p;
}
}
// member object of Person class as Cloneable. If it was not, then deep cloning //would not have been possible
class Salary implements Cloneable {
public int basic = 0;
public int bonus = 0;
public int getSalary() {
return basic + bonus;
}
// implementing clone()
protected Salary clone() throws CloneNotSupportedException {
Salary s = (Salary) super.clone();
return s;
}
}
// Cloneables with final fields - not meant go together. No error, but when try //to change, it cribs.
// The only solution is to remove the final modifier from the field, giving up //the benefits the modifier conferred.

No comments:

Post a Comment

Note: Only a member of this blog may post a comment.