Interfaz clonable en Java

La interfaz Java.lang.Cloneable es una interfaz de marcador . Fue introducido en JDK 1.0. Hay un método clon() en la clase Object. La interfaz clonable es implementada por una clase para hacer que el método Object.clone() sea válido y, por lo tanto, hacer una copia de campo por campo. Esta interfaz permite que la clase de implementación tenga sus objetos para ser clonados en lugar de usar un nuevo operador. 

Declaración

public interface Cloneable

Ejemplo 1: el programa a continuación explica que si intenta clonar un objeto que no implementa la interfaz Cloneable, CloneNotSupportedException , que es posible que desee manejar.

// Java program to Demonstrate the
// application of Cloneable interface
  
import java.io.*;
import java.util.*;
  
class Student {
  
    // attributes of Student class
    String name = null;
    int id = 0;
  
    // default constructor
    Student() {}
  
    // parameterized constructor
    Student(String name, int id)
    {
        this.name = name;
        this.id = id;
    }
    
    public static void main(String[] args)
    {
        // create an instance of Student
        Student s1 = new Student("Ashish", 121);
  
        // Try to clone s1 and assign
        // the new object to s2
        Student s2 = s1.clone();
    }
}

Producción:

prog.java:28: error: incompatible types: Object cannot be converted to Student
        Student s2 = s1.clone();
                             ^
1 error

Ejemplo 2: El siguiente código explica el uso adecuado de la interfaz Cloneable para hacer que el método Object.clone() sea legal. Las clases que implementan esta interfaz deben anular el método Object.clone() (que está protegido) para que pueda invocarse.

// Java program to illustrate Cloneable interface
import java.lang.Cloneable;
  
// By implementing Cloneable interface
// we make sure that instances of class A
// can be cloned.
class A implements Cloneable {
    int i;
    String s;
  
    // A class constructor
    public A(int i, String s)
    {
        this.i = i;
        this.s = s;
    }
  
    // Overriding clone() method
    // by simply calling Object class
    // clone() method.
    @Override
    protected Object clone()
        throws CloneNotSupportedException
    {
        return super.clone();
    }
}
  
public class Test {
    public static void main(String[] args)
        throws CloneNotSupportedException
    {
        A a = new A(20, "GeeksForGeeks");
  
        // cloning 'a' and holding
        // new cloned object reference in b
  
        // down-casting as clone() return type is Object
        A b = (A)a.clone();
  
        System.out.println(b.i);
        System.out.println(b.s);
    }
}

20
GeeksForGeeks

Copia profunda usando el método clon()

La clonación profunda de objetos es como crear una copia exacta del objeto original copiando los campos del objeto original al objeto clonado. Se asigna una memoria separada para los objetos clonados donde se copia el contenido del objeto original. El método clone() puede crear una copia superficial y profunda del objeto original en función de la implementación del mismo. La copia profunda crea una nueva memoria con el mismo contenido que el objeto original. Por eso, cuando cambiamos el contenido del objeto original después de la clonación, los cambios no se reflejan en el objeto clonado. Hay tipos de copias como Deep, Shallow y Lazy Copy . El siguiente código explica la copia profunda usando el método clone().

// A Java program to demonstrate deep copy
// using clone()
import java.util.ArrayList;
  
// An object reference of this class is
// contained by Test2
class Test {
    int x, y;
}
  
// Contains a reference of Test and implements
// clone with deep copy.
class Test2 implements Cloneable {
    int a, b;
  
    Test c = new Test();
  
    public Object clone() throws CloneNotSupportedException
    {
        // Assign the shallow copy to new reference variable
        // t
        Test2 t = (Test2)super.clone();
  
        t.c = new Test();
  
        // Create a new object for the field c
        // and assign it to shallow copy obtained,
        // to make it a deep copy
        return t;
    }
}
  
public class Main {
    public static void main(String args[])
        throws CloneNotSupportedException
    {
        Test2 t1 = new Test2();
        t1.a = 10;
        t1.b = 20;
        t1.c.x = 30;
        t1.c.y = 40;
  
        Test2 t3 = (Test2)t1.clone();
        t3.a = 100;
  
        // Change in primitive type of t2 will not
        // be reflected in t1 field
        t3.c.x = 300;
  
        // Change in object type field of t2 will not
        // be reflected in t1(deep copy)
        System.out.println(t1.a + " " + t1.b + " " + t1.c.x
                           + " " + t1.c.y);
        System.out.println(t3.a + " " + t3.b + " " + t3.c.x
                           + " " + t3.c.y);
    }
}

10 20 30 40
100 20 300 0

Nota: Esta interfaz no contiene el método de clonación. Por lo tanto, no es posible clonar un objeto simplemente por el hecho de que implementa esta interfaz. Incluso si el método de clonación se invoca reflexivamente, no hay garantía de que tenga éxito.

Referencia: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Cloneable.html