Java Clone Tutorial Purpose Ii - Representative To Override Amongst Mutable Plain

This is the minute business office of Java tutorial on Cloning, In first part nosotros conduct hold seen how clone method plant inward Java amongst a uncomplicated instance of cloning object, amongst primitives together with Immutable. In this tutorial, nosotros volition conduct hold 1 measuring farther together with override clone method for creating clone of object amongst mutable field. In our instance mutable champaign is a Collection here, to live precise a List. Since default implementation of clone() method exclusively does shallow re-create of objects, it tin create issue, if master copy object contains mutable object or Collection classes. In our example, nosotros conduct hold a aeroplane called Programmer, amongst String name, int historic menstruum together with List of Certifications. When nosotros override clone() method within Programmer class, nosotros involve to explicitly conduct hold assist of this List, otherwise, both master copy together with cloned object volition betoken to same Collection inward Java heap, which means, whatever alter e.g. adding a novel Certification inward master copy object volition too reverberate inward cloned object or vice-versa. Since an object should live independent of it's clone, nosotros involve to create this number past times applying deep cloning techniques. Along amongst this instance of overriding clone inward Java, In this Java clone tutorial business office 2, nosotros volition too conduct hold a facial expression at about Java best practices for implementing right clone method, disadvantages together with shortcomings of cloning inward Java together with inward item clone method together with finally, when to operate clone inward Java.

How to Override Clone method inward Java

There are about guidelines mentioned almost overriding clone method inward Java, e.g. telephone call upwards should live delegated to super.clone(), past times keeping that inward mind, next steps should live followed patch overriding clone() inward Java :

1) Let the class, which supports cloning implements Cloneable interface. (failure to do this volition number inward CloneNotSupportedException).

2) Override protected clone() method from java.lang.Object class.

3) In overridden clone(), kickoff telephone call upwards super.clone() to acquire the shallow re-create of object.

4) If your aeroplane contains whatever Collection or Mutable object, than deep copy of those field. Like inward our example, Programmer aeroplane contains List inward it's certification field, when super.clone() volition return, both master copy together with cloned object volition betoken to same object. To create this, nosotros reassign certification fields of clone object past times explicitly copying data, every bit shown inward next describe of piece of work :

clone.certifications = new ArrayList(certifications); //deep copying

5) Depending upon object, you lot may telephone call upwards it's clone method e.g. inward instance of java.util.Date or recursively re-create it's information into novel field. This whole procedure is known every bit deep copying. See hither to know how to deep re-create Java Collection.

Java Program to override Clone method amongst Mutable Field

Here is our sample Java computer programme which volition instruct you lot how to implement clone method for a aeroplane which contains a mutable field. Remember, clone should live just same every bit master copy object just they must live dissimilar object i.e. if 1 reference alter value of mutable fellow member than cloned object should non live affected past times that.

import java.util.ArrayList; import java.util.List; import org.slf4j.Logger; import org.slf4j.LoggerFactory;  /*  * Java computer programme to demo how to override clone method for deep copying.  * This instance includes a mutable filed inward aeroplane to live cloned to demo how you lot bargain amongst  * practical classes which contains both immutable together with mutable fields.  *  * @author Javin  */ public class CloneTest {      private static final Logger logger = LoggerFactory.getLogger(Cloneclass);      public static void main(String args[]) {               Programmer javaguru = new Programmer("John", 31);         javaguru.addCertificates("OCPJP");         javaguru.addCertificates("OCMJD");         javaguru.addCertificates("PMP");         javaguru.addCertificates("CISM");               logger.debug("Real Java Guru     : {}", javaguru);               Programmer clone = javaguru.clone();         logger.debug("Clone of Java Guru : {}", clone);               //let's add together about other certification to coffee guru         javaguru.addCertificates("Oracle DBA");         logger.debug("Real Java Guru     : {}", javaguru);         logger.debug("Clone of Java Guru : {}", clone);     } }  class Programmer implements Cloneable{     private static final Logger logger = LoggerFactory.getLogger(Programmer.class);       private String name;     private int age;     private List certifications ;      public Programmer(String name, int age) {         this.name = name;         this.age = age;         this.certifications = new ArrayList();     }      public int getAge() {         return age;     }      public void setAge(int age) {         this.age = age;     }      public String getName() {         return name;     }      public void setName(String name) {         this.name = name;     }       public void addCertificates(String certs){         certifications.add(certs);     }      @Override     public String toString() {         return String.format("%s, %d, Certifications: %s", name, age, certifications.toString());     }      @Override     protected Programmer clone()  {         Programmer clone = null;         try{             clone = (Programmer) super.clone();             clone.certifications = new ArrayList(certifications); //deep copying                   }catch(CloneNotSupportedException cns){             logger.error("Error patch cloning programmer", cns);         }         return clone;     }     }   Output of Shallow copying : [main] DEBUG CloneTest  - Real Java Guru     : John, 31, Certifications: [OCPJP, OCMJD, PMP, CISM] [main] DEBUG CloneTest  - Clone of Java Guru : John, 31, Certifications: [OCPJP, OCMJD, PMP, CISM] [main] DEBUG CloneTest  - Real Java Guru     : John, 31, Certifications: [OCPJP, OCMJD, PMP, CISM, Oracle DBA] [main] DEBUG CloneTest  - Clone of Java Guru : John, 31, Certifications: [OCPJP, OCMJD, PMP, CISM, Oracle DBA]  After deep copying collection: [main] DEBUG CloneTest  - Real Java Guru     : John, 31, Certifications: [OCPJP, OCMJD, PMP, CISM] [main] DEBUG CloneTest  - Clone of Java Guru : John, 31, Certifications: [OCPJP, OCMJD, PMP, CISM] [main] DEBUG CloneTest  - Real Java Guru     : John, 31, Certifications: [OCPJP, OCMJD, PMP, CISM, Oracle DBA] [main] DEBUG CloneTest  - Clone of Java Guru : John, 31, Certifications: [OCPJP, OCMJD, PMP, CISM]

Remember, this code volition piece of work because String is immutable, otherwise you lot tin non respond on re-create Constructor provided past times Collection classes, they exclusively render shallow re-create together with non deep copy. If you lot involve to deep re-create a collection, you lot involve to iterate over it together with clone each object separately.

Best Practices to follow patch overriding clone method inward Java

Now you lot know how to override clone method, it's fourth dimension to sharper your cognition together with acquire about best practices related to clone() method inward Java. We volition too look, what things to avoid, because best practices volition non yield whatever number if you lot don't halt next bad practices.

1) Return Sub aeroplane from clone() method, instead of returning java.lang.Object

One shortcoming of clone() method is that it render Object, which agency user of clone() method must do type casting to acquire right type of object. From Java 1.5 onwards an overriding method tin render subclass of render type declared inward master copy method, which agency you lot tin render sub aeroplane from clone method. It is known every bit co-variant method overriding. This volition preclude lot of type casting at customer side. Unfortunately clone() method of java.util.Date is non updated to conduct hold wages of this alter made inward Java 5. Which agency you lot involve to cast cloned object into Date, earlier using it.

2) Use deep copy, if your aeroplane contains whatever mutable field.

Remember to perform deep cloning earlier returning deep re-create of object, if it contains whatever mutable field. Java documentation of clone method says that, you lot may involve to modify for certain fields earlier returning them, to brand cloned object completely independent from master copy object. For instance inward java.util.Date method's clone method, nosotros are explicitly cloning cdate field, every bit shown below.

d = (Date)super.clone(); if (cdate != null) {   d.cdate = (BaseCalendar.Date) cdate.clone(); }

This measuring conflict amongst operate of lastly field, had cdate would live final, you lot tin non perform this step, because lastly fields tin non live reassigned 1 time initialized.

3) Don't throw CloneNotSupportedException.

One of the most annoying thing, patch using clone() method to re-create object is handling of checked exception, which is oftentimes necessary, because most of the time, customer exclusively telephone call upwards clone() method on object, they know supports cloning of objects. By catching CloneNotSupportedExcpetion internally inward overridden clone() method, you lot do a lot of favor to your clients. You tin conduct hold a facial expression at java.util.Date's clone() method for this example, which doesn't throw this exception.

/*  *  Return a re-create of this object.  */  public Object clone() {   Date d = null;   try {   d = (Date)super.clone();          if (cdate != null) {                 d.cdate = (BaseCalendar.Date) cdate.clone();          }   } catch (CloneNotSupportedException e) {} // Won't happen   return d;  } 

Shortcomings of Cloneable together with clone method inward Java

Cloneable together with clone() method has failed to run into expectation of creating re-create of object, it's 1 of the most criticized blueprint determination made past times Java API designers, along amongst checked exception together with perchance introducing NullPointerException. Apart from non providing deep re-create of Object, clone() method has several other problems together with because of that many Java programmers doesn't fifty-fifty override clone() method every bit oftentimes they override equals(), hashCode() together with compareTo() methods.


1) Well behaved implementation of clone() method is based on convention suggested inward Java documentation, rather than enforced past times design. Which agency it's fragile, every bit it makes it slow for Java programmer to forget those convention.


2) Your mightiness to correctly override clone() method strongly depends upon, how super aeroplane overrides it. If your super aeroplane is business office of whatever library, which is non inward your control, it decisively boundary your mightiness to create a good behaved clone() method inward Java.


3) Process of deep cloning inward Java, conflicts amongst proper operate of lastly fields, because if your Mutable object is a final field, you lot tin non reassign copied values within clone method.


4) Creating copies using clone() method is non natural, because it doesn't telephone call upwards constructor, which agency it doesn't leverage invariant enforced past times constructor of object, together with need extra assist patch copying, similar to deserializing an object.


5) Another annoying business office of clone() method is that it throws unnecessary checked exception inward cast of CloneNotSupportedExcpetion, which reduces readability of code.

6) Prior to Java 1.5, every caller of clone() method must involve to type cast cloned object into required type, though this tin live avoided past times returning right type from overridden clone() method from coffee v onwards.

When to operate Clone method inward Java

Given all these employment associated amongst clone() method, it's risky to operate it for creating copy, until you lot are absolutely for certain that corresponding aeroplane provides good behaved implementation of clone() method. I personally prefer to operate clone() method for creating copies of objects similar java.util.Date, which provides correctly overridden clone() method just too doesn't throw CloneNotSupportedException. Similarly, if your aeroplane exclusively contains primitives together with Immutable object you lot tin rely on shallow re-create created past times Object's clone() method. Another place, where you lot desire to operate clone() method inward Java is for cloning arrays. Apart from that, I would advise to prefer Copy Constructor together with Static Factory methods for creating objects from about other object. They don't come upwards amongst all problems, presented past times clone() method together with does the chore good past times creating exact copies.



That's all on How to override clone() method inward Java together with when to operate clone for creating re-create of an instance. We conduct hold too seen shortcoming of clone() methods to together with why it's operate is discouraged past times Java community, together with nosotros conduct hold too seen about Java best practices, which tin live followed patch overriding clone method, to minimize about annoying employment associated amongst clone() method inward Java. As suggested past times Joshua Bloch inward Effective Java Item 11, prefer Copy constructor together with Conversion factories over clone() method inward Java.

Further Reading
Java Fundamentals, Part 1 together with two
Core Java For the Impatient - Covers Java SE 8
Java Fundamentals: The Java Language

Share this post