Java Clone Tutorial Business Office Two - Representative To Override Amongst Mutable Plain

This is the minute purpose of Java tutorial on Cloning, In first part nosotros receive got seen how clone method industrial plant inwards Java alongside a uncomplicated instance of cloning object, alongside primitives as well as Immutable. In this tutorial, nosotros volition receive got 1 measuring farther as well as override clone method for creating clone of object alongside mutable field. In our instance mutable champaign is a Collection here, to last precise a List. Since default implementation of clone() method exclusively does shallow re-create of objects, it tin give notice create issue, if master copy object contains mutable object or Collection classes. In our example, nosotros receive got a shape called Programmer, alongside String name, int historic catamenia as well as List of Certifications. When nosotros override clone() method within Programmer class, nosotros require to explicitly receive got tending of this List, otherwise, both master copy as well as cloned object volition quest to same Collection inwards Java heap, which means, whatsoever alter e.g. adding a novel Certification inwards master copy object volition too reverberate inwards cloned object or vice-versa. Since an object should last independent of it's clone, nosotros require to laid upwards this number past times applying deep cloning techniques. Along alongside this instance of overriding clone inwards Java, In this Java clone tutorial purpose 2, nosotros volition too receive got a expression at but about Java best practices for implementing right clone method, disadvantages as well as shortcomings of cloning inwards Java as well as inwards item clone method as well as finally, when to usage clone inwards Java.

How to Override Clone method inwards Java

There are but about guidelines mentioned nearly overriding clone method inwards Java, e.g. telephone telephone should last delegated to super.clone(), past times keeping that inwards mind, next steps should last followed patch overriding clone() inwards Java :

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

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

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

4) If your shape contains whatsoever Collection or Mutable object, than deep copy of those field. Like inwards our example, Programmer shape contains List inwards it's certification field, when super.clone() volition return, both master copy as well as cloned object volition quest to same object. To laid upwards this, nosotros reassign certification fields of clone object past times explicitly copying data, every bit shown inwards next business :

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

5) Depending upon object, you lot may telephone telephone it's clone method e.g. inwards 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 alongside Mutable Field

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

import java.util.ArrayList; import java.util.List; import org.slf4j.Logger; import org.slf4j.LoggerFactory;  /*  * Java plan to demo how to override clone method for deep copying.  * This instance includes a mutable filed inwards shape to last cloned to demo how you lot bargain alongside  * practical classes which contains both immutable as well as 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 but 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 operate because String is immutable, otherwise you lot tin give notice non respond on re-create Constructor provided past times Collection classes, they exclusively furnish shallow re-create as well as non deep copy. If you lot require to deep re-create a collection, you lot require to iterate over it as well as clone each object separately.

Best Practices to follow patch overriding clone method inwards Java

Now you lot know how to override clone method, it's fourth dimension to sharper your noesis as well as larn but about best practices related to clone() method inwards Java. We volition too look, what things to avoid, because best practices volition non yield whatsoever final result if you lot don't halt next bad practices.

1) Return Sub shape 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 give notice render subclass of render type declared inwards master copy method, which agency you lot tin give notice render sub shape from clone method. It is known every bit co-variant method overriding. This volition foreclose lot of type casting at customer side. Unfortunately clone() method of java.util.Date is non updated to receive got wages of this alter made inwards Java 5. Which agency you lot require to cast cloned object into Date, earlier using it.

2) Use deep copy, if your shape contains whatsoever mutable field.

Remember to perform deep cloning earlier returning deep re-create of object, if it contains whatsoever mutable field. Java documentation of clone method says that, you lot may require to modify for sure fields earlier returning them, to brand cloned object completely independent from master copy object. For instance inwards 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 alongside usage of finally field, had cdate would last final, you lot tin give notice non perform this step, because finally fields tin give notice non last reassigned in 1 trial 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 oft necessary, because most of the time, customer exclusively telephone telephone clone() method on object, they know supports cloning of objects. By catching CloneNotSupportedExcpetion internally inwards overridden clone() method, you lot do a lot of favor to your clients. You tin give notice receive got a 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 as well as clone method inwards Java

Cloneable as well as clone() method has failed to come across expectation of creating re-create of object, it's 1 of the most criticized pattern determination made past times Java API designers, along alongside checked exception as well as mayhap introducing NullPointerException. Apart from non providing deep re-create of Object, clone() method has several other problems as well as because of that many Java programmers doesn't fifty-fifty override clone() method every bit oft they override equals(), hashCode() as well as compareTo() methods.


1) Well behaved implementation of clone() method is based on convention suggested inwards 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 shape overrides it. If your super shape is purpose of whatsoever library, which is non inwards your control, it decisively boundary your mightiness to create a good behaved clone() method inwards Java.


3) Process of deep cloning inwards Java, conflicts alongside proper usage of finally fields, because if your Mutable object is a final field, you lot tin give notice non reassign copied values within clone method.


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


5) Another annoying purpose of clone() method is that it throws unnecessary checked exception inwards shape of CloneNotSupportedExcpetion, which reduces readability of code.

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

When to usage Clone method inwards Java

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



That's all on How to override clone() method inwards Java as well as when to usage clone for creating re-create of an instance. We receive got too seen shortcoming of clone() methods to as well as why it's usage is discouraged past times Java community, as well as nosotros receive got too seen but about Java best practices, which tin give notice last followed patch overriding clone method, to minimize but about annoying work associated alongside clone() method inwards Java. As suggested past times Joshua Bloch inwards Effective Java Item 11, prefer Copy constructor as well as Conversion factories over clone() method inwards Java.

Further Reading
Java Fundamentals, Part 1 as well as ii
Core Java For the Impatient - Covers Java SE 8
Java Fundamentals: The Java Language