Types of Cloning in Java

In the world of Java programming, cloning plays a critical function in growing identical copies of items. It presents a mechanism for duplicating an item's country, permitting developers to paintings with copies without affecting the original item. Java offers a couple of methods to attain cloning, every with its personal traits and use instances. In this section, we will explore three types of cloning in Java: Shallow Cloning and Deep Cloning.

Shallow Cloning

Shallow cloning creates a brand new item and copies the fields of the authentic item into the brand new one. However, if the authentic item includes the references to different gadgets, the ones references are shared between the original and the cloned items. In different phrases, the cloning process only creates the copies of the references, no longer the referenced items.

Let's illustrate shallow cloning with an easy example:

ShallowCloneExample.java

class Employee implements Cloneable {
    private String name;
    private int employeeId;
    public Employee(String name, int employeeId) {
        this.name = name;
        this.employeeId = employeeId;
    }
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    public String toString() {
        return "Employee{name='" + name + "', employeeId=" + employeeId + '}';
    }
}
public class ShallowCloneExample {
    public static void main(String[] args) {
        try {
            // Creating an original object
            Employee originalEmployee = new Employee("John Doe", 123);
           // Shallow cloning the original object
            Employee clonedEmployee = (Employee) originalEmployee.clone();
            // Modifying the cloned object
            clonedEmployee.name = "Jane Doe";
            clonedEmployee.employeeId = 456;
            // Printing original and cloned objects
            System.out.println("Original Employee: " + originalEmployee);
            System.out.println("Cloned Employee: " + clonedEmployee);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

Output:

Original Employee: Employee{name='Jane Doe', employeeId=456}
Cloned Employee: Employee{name='Jane Doe', employeeId=456}

As seen in the output, the modifications made to the cloned item additionally affect the unique object. This conduct is because of the shared references among the original and cloned objects.

Deep Cloning

Deep cloning, alternatively, creates a totally independent reproduction of the authentic item, together with all the referenced gadgets. It ensures that adjustments made to the cloned object do now not impact the authentic object or vice versa.

Let's enforce deep cloning using the clone method and serialization:

DeepCloneExample.java

import java.io.*;
class Address implements Serializable {
    String city;
    String state;
    Address(String city, String state) {
        this.city = city;
        this.state = state;
    }
}
class Person implements Serializable {
    String name;
    int age;
    Address address;
    Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
}
public class DeepCloneExample {
    public static <T> T deepClone(T object) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(bos);
            out.writeObject(object);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream in = new ObjectInputStream(bis);
            return (T) in.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
    public static void main(String[] args) {
        // Creating an original object with nested objects
        Address originalAddress = new Address("Cityville", "Stateland");
        Person originalPerson = new Person("John Doe", 30, originalAddress);
       // Deep cloning the original object
        Person clonedPerson = deepClone(originalPerson);
        // Modifying the cloned object
        clonedPerson.name = "Jane Doe";
        clonedPerson.age = 25;
        clonedPerson.address.city = "Townsville";
        // Printing original and cloned objects
        System.out.println("Original Person: " + originalPerson.name + ", " + originalPerson.age + ", " + originalPerson.address.city);
        System.out.println("Cloned Person: " + clonedPerson.name + ", " + clonedPerson.age + ", " + clonedPerson.address.city);
    }
}

Output:

Original Person: John Doe, 30, Cityville
Cloned Person: Jane Doe, 25, Townsville

In the realization, the exploration of cloning techniques in Java well-known indicates a diverse set of techniques, every with its personal strengths and issues. Shallow cloning is an honest technique, but it comes with the caveat of shared references, impacting the precise and cloned gadgets simultaneously.

On the other hand, deep cloning ensures the independence through manner of replicating now not exceptional the object's fields but also the referenced gadgets, imparting an extra complete duplication of the object's space. It's important to be aware that the selection between those cloning methods have to be made with a radical know-how of the object's shape, relationships, and the preferred conduct of the cloned objects. Moreover, developers have to consider factors which include overall performance, memory usage, and the capability effect at the application's overall layout.

Next TopicWhat is portable in Java

← prev next →