Java Object clone() Method

The Object.clone() method in Java is used to create and return a copy of an object.

Table of Contents

1. Introduction
2. clone() Method Syntax
3. Examples
   • Basic Cloning
   • Shallow Cloning
   • Deep Cloning
4. Real-World Use Case
5. Conclusion

Introduction

The Object.clone() method is a member of the Object class in Java. It provides a way to create a new instance of a class with the same state as an existing instance. By default, the clone() method performs a shallow copy of the object, meaning it copies the object's fields but not the objects referenced by those fields.

clone()() Method Syntax

The syntax for the clone() method is as follows:

protected Object clone() throws CloneNotSupportedException

The method returns a new object that is a copy of the current instance. If the object's class does not implement the Cloneable interface, the clone() method throws a CloneNotSupportedException.

Examples

Basic Cloning

To use the clone() method, a class must implement the Cloneable interface and override the clone() method to provide public access.

Example

class Person implements Cloneable {
    String name;
    int age;

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

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

public class CloneExample {
    public static void main(String[] args) {
        try {
            Person person1 = new Person("Ramesh", 30);
            Person person2 = (Person) person1.clone();
            
            System.out.println("Original: " + person1.name + ", " + person1.age);
            System.out.println("Clone: " + person2.name + ", " + person2.age);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

Output:

Original: Ramesh, 30
Clone: Ramesh, 30

Shallow Cloning

Shallow cloning copies the fields of the object but not the objects referenced by the fields.

Example

class Address {
    String city;
    String state;

    Address(String city, String state) {
        this.city = city;
        this.state = state;
    }
}

class Employee implements Cloneable {
    String name;
    Address address;

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

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

public class ShallowCloneExample {
    public static void main(String[] args) {
        try {
            Address address = new Address("Mumbai", "Maharashtra");
            Employee emp1 = new Employee("Suresh", address);
            Employee emp2 = (Employee) emp1.clone();
            
            System.out.println("Original: " + emp1.name + ", " + emp1.address.city);
            System.out.println("Clone: " + emp2.name + ", " + emp2.address.city);
            
            emp2.address.city = "Pune";
            System.out.println("After modification:");
            System.out.println("Original: " + emp1.address.city);
            System.out.println("Clone: " + emp2.address.city);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

Output:

Original: Suresh, Mumbai
Clone: Suresh, Mumbai
After modification:
Original: Pune
Clone: Pune

Deep Cloning

Deep cloning involves creating copies of the objects referenced by the fields, ensuring that the cloned object is completely independent of the original.

Example

class Address implements Cloneable {
    String city;
    String state;

    Address(String city, String state) {
        this.city = city;
        this.state = state;
    }

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

class Employee implements Cloneable {
    String name;
    Address address;

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

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

public class DeepCloneExample {
    public static void main(String[] args) {
        try {
            Address address = new Address("Mumbai", "Maharashtra");
            Employee emp1 = new Employee("Suresh", address);
            Employee emp2 = (Employee) emp1.clone();
            
            System.out.println("Original: " + emp1.name + ", " + emp1.address.city);
            System.out.println("Clone: " + emp2.name + ", " + emp2.address.city);
            
            emp2.address.city = "Pune";
            System.out.println("After modification:");
            System.out.println("Original: " + emp1.address.city);
            System.out.println("Clone: " + emp2.address.city);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

Output:

Original: Suresh, Mumbai
Clone: Suresh, Mumbai
After modification:
Original: Mumbai
Clone: Pune

Real-World Use Case

Cloning Configuration Objects

In a real-world scenario, you might need to clone configuration objects to create isolated copies for different threads or processes.

Example

class Configuration implements Cloneable {
    String dbUrl;
    String user;
    String password;

    Configuration(String dbUrl, String user, String password) {
        this.dbUrl = dbUrl;
        this.user = user;
        this.password = password;
    }

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

public class ConfigurationCloneExample {
    public static void main(String[] args) {
        try {
            Configuration config1 = new Configuration("jdbc:mysql://localhost:3306/mydb", "root", "password");
            Configuration config2 = (Configuration) config1.clone();
            
            System.out.println("Original Config: " + config1.dbUrl);
            System.out.println("Cloned Config: " + config2.dbUrl);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

Output:

Original Config: jdbc:mysql://localhost:3306/mydb
Cloned Config: jdbc:mysql://localhost:3306/mydb

Conclusion

The Object.clone() method in Java provides a way to create a copy of an object. By understanding how to use this method, you can efficiently create object copies in your Java applications. Whether you are performing shallow or deep cloning, handling potential CloneNotSupportedException, or using clones in real-world scenarios, the clone() method is a valuable tool for managing object state and creating duplicates.