How Clone Method Industrial Plant Inwards Java?

The clone() is a tricky method from java.lang.Object class, which is used to practise a re-create of an Object inwards Java. The intention of the clone() method is simple, to furnish a cloning mechanism, precisely somehow it's implementation became tricky too has been widely criticized from a long time. Anyway, nosotros volition non decease to classic ground of clone inwards Java, at to the lowest degree for now; instead, nosotros volition endeavor to larn how clone method industrial plant inwards Java. To live fair, understating cloning machinery inwards Java is non slowly too fifty-fifty experienced Java programmer neglect to explicate how cloning of mutable object works, or a difference betwixt deep too shallow re-create inwards Java.

In this three-part article, nosotros volition start run across working of clone method inwards Java, too inwards minute purpose nosotros volition larn how to override clone method inwards Java, too lastly nosotros volition beak over deep re-create vs shallow copy mechanism.

The ground I chose to brand this a three-part article is to proceed the focus on ane affair at a time. Since clone() itself is confusing enough, it's best to sympathise concept ane past times one. In this post, nosotros volition larn what is clone method, what it does too How clone method industrial plant inwards Java.

By the way, clone() is ane of the few telephone commutation methods defined past times objects, others beingness equals, hashcode(), toString() along amongst hold back too notify methods.

What is the clone of an object inwards Java?

An object which is returned past times the clone() method is known every bit a clone of master copy instance. Influenza A virus subtype H5N1 clone object should follow basic characteristics e.g. a.clone() != a, which way master copy too clone are 2 dissever object inwards Java heap, a.clone().getClass() == a.getClass() too clone.equals(a), which way clone is exact re-create of master copy object. This feature is followed past times a good behaved, correctly overridden clone() method inwards Java, precisely it's non enforced past times the cloning mechanism. Which means, an object returned past times clone() method may violate whatever of these rules.

By next the convention of returning an object past times calling super.clone(), when overriding clone() method, yous tin ensure that it follows start 2 characteristics. In gild to follow the tertiary characteristic, yous must override equals method to enforce logical comparison, instead of physical comparing exists inwards java.lang.Object.

For example, clone() method of Rectangle shape inwards this method render object, which has these characteristics, precisely if yous run the same plan past times commenting equals(), you will run across that tertiary invariant i.e. clone.equals(a) volition render false. By the way in that place are a brace of skilful items on Effective Java regarding effective utilization of clone method, I highly recommend to read those items later going through this article.

How Clone method industrial plant inwards Java

protected too native in Object class, thus implemented inwards native code. Since its convention to render clone() of an object past times calling super.clone() method, whatever cloning procedure eventually reaches to java.lang.Object clone() method. This method, start checks if the corresponding object implements Cloneable interface, which is a marking interface. If that instance doesn't implement Cloneable too then it throws CloneNotSupportedException inwards Java, a checked exception, which is ever required to live handled spell cloning an object. If an object passes this check, than java.lang.Object's clone() method creates a shallow re-create of the object too returned it to the caller.


Since Object class' clone() method creates re-create past times creating novel instance, too and then copying field-by-field, similar to assignment operator, it's fine for primitives too Immutable object, precisely non suited if your shape contains or thus mutable information construction e.g. Collection classes like ArrayList or arrays. In that case, both master copy object too re-create of the object volition indicate to the same object inwards the heap. You tin preclude this past times using the technique known every bit deep cloning, on which each mutable plain is cloned separately. In short, hither is how clone method industrial plant inwards Java:

1) Any shape calls clone() method on an instance, which implements Cloneable and overrides protected clone() method from Object class, to practise a copy.

  Rectangle rec = new Rectangle(30, 60);

  logger.info(rec);

      

    try {

         logger.info("Creating Copy of this object using Clone method");

         Rectangle re-create = rec.clone();

         logger.info("Copy " + copy);

          

    } catch (CloneNotSupportedException ex) {

         logger.debug("Cloning is non supported for this object");

    }

2) Call to clone() method on Rectangle is delegated to super.clone(), which tin live a custom superclass or past times default java.lang.Object

    @Override

    protected Rectangle clone() throws CloneNotSupportedException {

        return (Rectangle) super.clone();

    }

3) Eventually, telephone phone reaches to java.lang.Object's clone() method, which verify if the corresponding instance implements Cloneable interface, if non too then it throws CloneNotSupportedException, otherwise it creates a field-by-field re-create of the instance of that shape too returned to the caller.

So inwards gild for clone() method to operate properly, 2 things necessitate to happen, a class should implement Cloneable interface too should override clone() method of Object class.

By the way this was this was the simplest representative of overriding clone method too how it works, things gets to a greater extent than complicated amongst existent object, which contains mutable fields, arrays, collections, Immutable object, and primitives, which nosotros volition run across inwards second part of this Java Cloning tutorial series.

Here is how  a shallow re-create of an object looks like:

Java clone() method Example

In this article, nosotros accept non seen complexity of overriding clone method inwards Java, every bit our Rectangle shape is real unproblematic too solely contains primitive fields, which way shallow cloning provided past times Object's clone() method is enough. But, this representative is of import to sympathise the procedure of Object cloning inwards Java, too how clone method works. Here is consummate code of this clone() method overriding example:

import org.apache.log4j.Logger;

/**

  * Simple representative of overriding clone() method inwards Java to sympathise How Cloning of

  * Object industrial plant inwards Java.

  *

  * @author

 */

public class JavaCloneTest {

    private static final Logger logger = Logger.getLogger(JavaCloneTest.class);

  

    public static void main(String args[]) {

        Rectangle rec = new Rectangle(30, 60);

        logger.info(rec);

      

        Rectangle re-create = null;

        try {

            logger.info("Creating Copy of this object using Clone method");

            copy = rec.clone();

            logger.info("Copy " + copy);

          

        } catch (CloneNotSupportedException ex) {

            logger.debug("Cloning is non supported for this object");

        }

      

        //testing properties of object returned past times clone method inwards Java

        logger.info("copy != rec : " + (copy != rec));

        logger.info("copy.getClass() == rec.getClass() : " + (copy.getClass() == rec.getClass()));

        logger.info("copy.equals(rec) : " + copy.equals(rec));

      

        //Updating fields inwards master copy object

        rec.setHeight(100);

        rec.setWidth(45);

      

        logger.info("Original object :" + rec);

        logger.info("Clonned object  :" + copy);

    }

 

}

public class Rectangle implements Cloneable{

    private int width;

    private int height;

  

    public Rectangle(int w, int h){

        width = w;

        height = h;

    }

    public void setHeight(int height) {

        this.height = height;

    }

    public void setWidth(int width) {

        this.width = width;

    }

  

    public int area(){

        return widthheight;

    }

  

    @Override

    public String toString(){

        return String.format("Rectangle [width: %d, height: %d, area: %d]", width, height, area());

    }

    @Override

    protected Rectangle clone() throws CloneNotSupportedException {

        return (Rectangle) super.clone();

    }

    @Override

    public boolean equals(Object obj) {

        if (obj == null) {

            return false;

        }

        if (getClass() != obj.getClass()) {

            return false;

        }

        final Rectangle other = (Rectangle) obj;

        if (this.width != other.width) {

            return false;

        }

        if (this.height != other.height) {

            return false;

        }

        return true;

    }

    @Override

    public int hashCode() {

        int hash = 7;

        hash = 47  hash + this.width;

        hash = 47  hash + this.height;

        return hash;

    }

  

  

  

}

Output:

2013-05-20 23:46:58,882 0    [main] INFO  JavaCloneTest  - Rectangle [width: 30, height: 60, area: 1800]

2013-05-20 23:46:58,882 0    [main] INFO  JavaCloneTest  - Creating Copy of this object using Clone method

2013-05-20 23:46:58,882 0    [main] INFO  JavaCloneTest  - Copy Rectangle [width: 30, height: 60, area: 1800]

2013-05-20 23:46:58,882 0    [main] INFO  JavaCloneTest  - re-create != rec : true

2013-05-20 23:46:58,882 0    [main] INFO  JavaCloneTest  - copy.getClass() == rec.getClass() : true

2013-05-20 23:46:58,882 0    [main] INFO  JavaCloneTest  - copy.equals(rec) : true

2013-05-20 23:46:58,882 0    [main] INFO  JavaCloneTest  - Original object :Rectangle [width: 45, height: 100, area: 4500]

2013-05-20 23:46:58,882 0    [main] INFO  JavaCloneTest  - Cloned object  :Rectangle [width: 30, height: 60, area: 1800]

From the output, yous tin clearly run across that cloned object has the same attribute every bit the master copy object inwards Java. Also changing the attribute of an master copy object is non affecting the dry ground of re-create object because they solely comprise primitive fields. If they had contained whatever mutable object, it would accept affected both of them.

You tin besides run across that it follow criterion properties of cloned object i.e.

• clone != original, 
• clone.getClass() == original.getClass(), and 
• clone.equals(original).

Things to Remember - Clone method inwards Java

1) The clone() method is used to practise a re-create of an object inwards Java. In gild to utilization clone() method, shape must implement java.lang.Cloneable interface too override protected clone() method from java.lang.Object.

Influenza A virus subtype H5N1 telephone phone to clone() method volition outcome inwards CloneNotSupportedException if that shape doesn't implement Cloneable interface.

2) No constructor is called during cloning of Object inwards Java.

3) Default implementation of clone() method inwards Java provides "shallow copy" of object, because it creates re-create of Object past times creating novel instance too and then copying content past times assignment, which way if your shape contains a mutable field, too then both master copy object too clone volition refer to same internal object. This tin live unsafe because whatever alter made on that mutable plain volition reverberate inwards both master copy too re-create object. In gild to avoid this, override clone() method to furnish the deep re-create of an object.

4) By convention, clone of an instance should live obtained past times calling super.clone() method, this volition assistance to save invariant of object created past times clone() method i.e. clone != original too clone.getClass() == original.getClass(). Though these are non absolute requirement every bit mentioned inwards Javadoc.

5) Influenza A virus subtype H5N1 shallow re-create of an instance is fine, until it solely contains primitives too Immutable objects, otherwise, yous necessitate to modify ane or to a greater extent than mutable fields of object returned past times super.clone(), earlier returning it to caller.

That's all on How clone method industrial plant inwards Java. Now nosotros know, what is the clone too what is Cloneable interface, a brace of things close clone method too what does default implementation of clone method practise inwards Java. This information is plenty to movement ahead too read second part of this Java cloning tutorial, on which nosotros volition learn, how to override clone() method inwards Java, for classes composed amongst primitives, mutable too immutable objects inwards Java.


Further Learning
Complete Java Masterclass
Java Fundamentals: The Java Language
Java In-Depth: Become a Complete Java Engineer!

Sumber https://javarevisited.blogspot.com/

Share this post