Cloning in Java

Posted Apr 7, 2024

By Alexander Chuev

6 min read

Introduction

Cloning in Java is a process of creating an exact copy of an object. It provides a way to duplicate objects without having to re-create them from scratch. This can be particularly useful in scenarios where creating a new object is resource-intensive or where the state of an existing object needs to be preserved.

In this article, we will explore what cloning is, how to use it in Java, and the best practices and caveats associated with cloning objects.

What is Cloning?

Cloning is a process of creating a new instance of a class that is a copy of an existing instance. In Java, cloning is achieved using the Cloneable interface and the clone() method provided by the Object class.

The Cloneable Interface

The Cloneable interface is a marker interface, meaning it does not contain any methods. It serves to indicate that a class is capable of being cloned.

The Clone Method

The clone() method is defined in the Object class. It is a protected method, meaning it is not directly accessible. To use clone(), a class must:

Implement the Cloneable interface.
Override the clone method and make it public.

Example of Cloning

Here is a basic example demonstrating how to clone an object in Java.

        
      
class Person implements Cloneable {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}


public class Main {
    public static void main(String[] args) {
        try {
            Person original = new Person("Alice", 30);
            Person cloned = (Person) original.clone();

            System.out.println("Original: " + original);
            System.out.println("Cloned: " + cloned);

            cloned.name = "Bob";
            cloned.age = 25;

            System.out.println("After modification");
            System.out.println("Original: " + original);
            System.out.println("Cloned: " + cloned);

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

In this example, the Person class implements Cloneable and overrides the clone method. The clone method uses super.clone() to create a copy of the object. The Main class demonstrates creating and modifying a cloned object.

Types of Cloning

There are two types of cloning in Java:

Shallow Cloning
Deep Cloning

Shallow Cloning

Shallow cloning creates a new instance of the object with the same values for its fields as the original object. If the object contains references to other objects, the references are copied, not the objects themselves. This means both the original and the cloned object will reference the same objects.

Example of Shallow Cloning

        
      
class Address {

    private String city;

    public Address(String city) {
        this.city = city;
    }
}

class Employee implements Cloneable {

    private String name;
    private Address address;

    public Employee(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Employee{name='" + name + "', address=" + address.city + "}";
    }
}


public class Main {
    public static void main(String[] args) {
        try {
            Address address = new Address("New York");
            Employee original = new Employee("John", address);
            Employee cloned = (Employee) original.clone();

            System.out.println("Original: " + original);
            System.out.println("Cloned: " + cloned);

            cloned.address.city = "Los Angeles";

            System.out.println("After modification");
            System.out.println("Original: " + original);
            System.out.println("Cloned: " + cloned);

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

In this example, modifying the city field of the cloned object’s address will also affect the original object because both objects share the same Address instance.

Deep Cloning

Deep cloning creates a new instance of the object along with new instances of the objects it references. This means changes to the cloned object will not affect the original object and vice versa.

Example of Deep Cloning

        
      
class Address implements Cloneable {
    
    private String city;

    public Address(String city) {
        this.city = city;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}


class Employee implements Cloneable {
    private String name;
    private Address address;

    public Employee(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        Employee cloned = (Employee) super.clone();
        cloned.address = (Address) address.clone();
        return cloned;
    }

    @Override
    public String toString() {
        return "Employee{name='" + name + "', address=" + address.city + "}";
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            Address address = new Address("New York");
            Employee original = new Employee("John", address);
            Employee cloned = (Employee) original.clone();

            System.out.println("Original: " + original);
            System.out.println("Cloned: " + cloned);

            cloned.address.city = "Los Angeles";

            System.out.println("After modification");
            System.out.println("Original: " + original);
            System.out.println("Cloned: " + cloned);

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

In this example, modifying the city field of the cloned object’s address will not affect the original object because each Employee object has its own Address instance.

Best Practices and Caveats

Implement Cloneable and Override the Clone Method

Always implement the Cloneable interface and override the clone method to ensure that cloning works as expected. The default clone method in the Object class is protected, so it must be overridden and made public.

Use super.clone()

Use super.clone() to create the initial copy of the object. This method creates a shallow copy of the object.

Handle CloneNotSupportedException

The clone method can throw a CloneNotSupportedException if the object’s class does not implement the Cloneable interface. Always handle this exception appropriately.

Consider Deep Cloning

If your class contains references to mutable objects, consider implementing deep cloning to ensure that the cloned object and the original object do not share references to the same objects.

Avoid Cloning in Complex Hierarchies

Cloning can become complex and error-prone in classes with complex inheritance hierarchies. In such cases, consider using other mechanisms such as copy constructors or serialization.

Conclusion

Cloning in Java provides a way to create exact copies of objects, which can be useful in various scenarios. By understanding the differences between shallow and deep cloning and following best practices, you can effectively implement cloning in your Java applications. Cloning can simplify the process of duplicating objects, but it also requires careful handling to ensure that objects are cloned correctly and efficiently.

advanced-java