Object Cloning In Java
Introduction
Object cloning in Java is a mechanism used to create a copy of an existing object. Instead of manually copying every field from one object to another, Java provides a built-in cloning mechanism through the clone() method and the Cloneable interface. At a surface level, cloning may appear to be a simple duplication process, but in reality, it introduces several important concepts related to memory management, object references, shallow copying, deep copying, and class design.
In real-world applications, cloning becomes useful when creating duplicate objects that initially share the same state as an existing object. This is commonly seen in caching systems, game development, object templates, configuration duplication, and frameworks where object creation is expensive or repetitive.
However, object cloning in Java has historically been considered one of the more controversial areas of the language because it is easy to misuse if the developer does not fully understand how references and memory allocation work internally. Simply copying an object reference is not the same as cloning an object, and this distinction is extremely important.
In this tutorial, we will explore how cloning works in Java, why the Cloneable interface is required, how shallow copy differs from deep copy, what problems developers commonly face while cloning objects, and why modern Java applications often prefer alternative approaches such as copy constructors.
Understanding Object References Before Cloning
Before learning cloning, it is important to understand how object assignment works in Java.
Consider the following example:
Employee emp1 = new Employee();
Employee emp2 = emp1;
At first glance, many beginners assume that emp2 becomes a separate copy of emp1. However, that is not what actually happens.
In Java, objects are accessed through references. The statement:
emp2 = emp1;
does not create a new object. Instead, both variables point to the same object in memory.
This means that if one reference modifies the object, the changes become visible through the other reference as well.
For example:
emp1.name = "John";
System.out.println(emp2.name);
Output:
John
This happens because both references point to the same object instance.
Cloning solves this problem by creating a completely separate object with the same data.
What is Object Cloning?
Object cloning is the process of creating a duplicate copy of an existing object.
Java supports cloning through:
- The
clone()method - The
Cloneablemarker interface
The clone() method is defined in the Object class:
protected Object clone() throws CloneNotSupportedException
Since every Java class indirectly extends the Object class, every class technically inherits the clone() method. However, simply calling clone() is not enough because Java imposes additional restrictions for safety.
Why Cloneable Interface is Required
To make an object cloneable, the class must implement the Cloneable interface. Example:
class Employee implements Cloneable {
}
The Cloneable interface is known as a marker interface because it does not contain any methods. Its purpose is simply to inform the JVM that cloning is allowed for this class.
If a class does not implement Cloneable and the clone() method is invoked, Java throws a CloneNotSupportedException.
This behavior prevents accidental cloning of objects that were not designed to be safely copied.
Basic Cloning Example
Let us start with a simple cloning example.
class Employee implements Cloneable {
int id;
String name;
Employee(int id, String name) {
this.id = id;
this.name = name;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
Now let us create and clone an object.
public class Main {
public static void main(String[] args)
throws CloneNotSupportedException {
Employee emp1 = new Employee(101, "John");
Employee emp2 = (Employee) emp1.clone();
System.out.println(emp1.id + " " + emp1.name);
System.out.println(emp2.id + " " + emp2.name);
}
}
Output:
101 John
101 John
In this example, emp2 becomes a separate object containing the same data as emp1.
The statement:
(Employee) emp1.clone();
creates a copy of the original object.
Understanding super.clone()
One of the most important parts of cloning is the following line:
return super.clone();
The actual cloning logic is implemented inside the Object class. Therefore, most classes delegate the cloning operation to the superclass implementation using super.clone().
The Object.clone() method performs a field-by-field copy of the object and creates a new instance in memory.
However, this default implementation performs only a shallow copy.
Understanding shallow copy is extremely important because many bugs in cloning arise from misunderstanding this behavior.
What is Shallow Copy?
A shallow copy creates a new object, but the internal referenced objects are not duplicated.
Primitive fields are copied normally because they store actual values. However, object references are copied as references, not as separate objects.
Consider the following example:
class Address {
String city;
Address(String city) {
this.city = city;
}
}
class Employee implements Cloneable {
int id;
String name;
Address address;
Employee(int id, String name, Address address) {
this.id = id;
this.name = name;
this.address = address;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
Now let us test cloning.
public class Main {
public static void main(String[] args)
throws CloneNotSupportedException {
Address address = new Address("Pune");
Employee emp1 =
new Employee(101, "John", address);
Employee emp2 =
(Employee) emp1.clone();
emp2.address.city = "Mumbai";
System.out.println(emp1.address.city);
}
}
Output:
Mumbai
Many developers expect the original object's city to remain "Pune", but the value changes to "Mumbai". This happens because both cloned objects share the same Address object reference. The outer object was duplicated, but the nested object was not. This is called shallow copying.
Visualizing Shallow Copy
It helps to mentally visualize what happens during shallow copy.
When cloning occurs:
- A new
Employeeobject is created. - Primitive values are copied.
- Reference variables are copied as references.
As a result:
emp1.address -----> Address Object
emp2.address -----> Same Address Object
Both objects point to the same nested object. This is why modifying the nested object through one reference affects the other object as well.
What is Deep Copy?
Deep copy solves the shallow copy problem by duplicating not only the main object but also all internally referenced mutable objects.
In a deep copy:
- The parent object is copied.
- Child objects are also copied.
- Separate memory allocation happens for nested objects.
As a result, changes in one object do not affect the other.
Implementing Deep Copy in Java
To create a deep copy, nested objects must also be cloned manually.
First, make the nested class cloneable.
class Address implements Cloneable {
String city;
Address(String city) {
this.city = city;
}
public Object clone()
throws CloneNotSupportedException {
return super.clone();
}
}
Now modify the Employee clone method.
class Employee implements Cloneable {
int id;
String name;
Address address;
Employee(int id, String name, Address address) {
this.id = id;
this.name = name;
this.address = address;
}
public Object clone()
throws CloneNotSupportedException {
Employee cloned =
(Employee) super.clone();
cloned.address =
(Address) address.clone();
return cloned;
}
}
Now test again.
public class Main {
public static void main(String[] args)
throws CloneNotSupportedException {
Address address =
new Address("Pune");
Employee emp1 =
new Employee(101, "John", address);
Employee emp2 =
(Employee) emp1.clone();
emp2.address.city = "Mumbai";
System.out.println(emp1.address.city);
System.out.println(emp2.address.city);
}
}
Output:
Pune
Mumbai
Now the original object remains unchanged because both objects contain separate Address instances. This is deep cloning.
Conclusion
Object cloning in Java is much more than simply copying data from one object to another. It introduces important ideas related to memory references, object identity, shallow copying, deep copying, and internal JVM behavior. While Java provides built-in cloning support through the clone() method and the Cloneable interface, developers must understand the limitations and complexities associated with the mechanism before using it in production systems.
The biggest challenge with cloning is that the default behavior performs shallow copying, which can unintentionally share internal mutable objects between the original and cloned instances. To avoid such issues, developers often implement deep cloning manually or choose alternative copying strategies such as copy constructors.
Even though many modern Java applications avoid direct usage of clone(), understanding object cloning remains extremely valuable because it deepens understanding of object-oriented programming, reference handling, memory allocation, and Java internals. These concepts appear frequently in interviews, framework development, and enterprise-level application design.