> For the complete documentation index, see [llms.txt](https://gyansetu-core-java-for-java.gitbook.io/project/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://gyansetu-core-java-for-java.gitbook.io/project/15-cloning-and-immutable-class/untitled-2.md).

# Untitled

| Topic                                     |   |
| ----------------------------------------- | - |
| Simple Cloning of objects with primitives |   |
| Shallow                                   |   |
| Deep Object inside Object                 |   |
| Cloning with inheritance (Shallow)        |   |
| Cloning with inheritance (Deep)           |   |
| Serialization                             |   |
| Apache commons util                       |   |
| Copy constructor                          |   |
| Cloning objects with collections          |   |
| Copy Constructor                          |   |
| Best practices                            |   |

Object cloning refers to creation of exact copy of an object. It creates a new instance of the class of current object and initializes all its fields with exactly the contents of the corresponding fields of this object.

**Using Assignment Operator to create copy of reference variable**\
In Java, there is no operator to create copy of an object. Unlike C++, in Java, if we use assignment operator then it will create a copy of reference variable and not the object. This can be explained by taking an example. Following program demonstrates the same.

```java
package com.gs.corejava.collections;

//Java program to demonstrate that assignment 
//operator only creates a new reference to same 
//object. 

//A test class whose objects are cloned 
class Test {
	int x, y;

	Test() {
		x = 10;
		y = 20;
	}
}

// Driver Class
public class Main {
	public static void main(String[] args) {
		Test ob1 = new Test();

		System.out.println(ob1.x + " " + ob1.y);

		// Creating a new reference variable ob2
		// pointing to same address as ob1
		Test ob2 = ob1;

		// Any change made in ob2 will be reflected
		// in ob1
		ob2.x = 100;

		System.out.println(ob1.x + " " + ob1.y);
		System.out.println(ob2.x + " " + ob2.y);
	}
}
```

**Output:**

```
10 20
100 20
100 20
```

**Creating a copy using clone() method**

The class whose object’s copy is to be made must have a public clone method in it or in one of its parent class.

* Every class that implements clone() should call super.clone() to obtain the cloned object reference.
* The class must also implement java.lang.Cloneable interface whose object clone we want to create otherwise it will throw CloneNotSupportedException when clone method is called on that class’s object.
* Syntax:

  ```
    protected Object clone() throws CloneNotSupportedException
  ```

```java
package com.gs.corejava.collections;

//Java program to demonstrate that assignment 
//operator only creates a new reference to same 
//object. 

//A test class whose objects are cloned 
class Test implements Cloneable {
	int x, y;

	Test() {
		x = 10;
		y = 20;
	}

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

// Driver Class
public class Main {
	public static void main(String[] args) {
		Test ob1 = new Test();

		System.out.println(ob1.x + " " + ob1.y);

		// Creating a new reference variable ob2
		// pointing to same address as ob1
		Test ob2 = null;
		try {
			ob2 = (Test) ob1.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		// Any change made in ob2 will be reflected
		// in ob1
		ob2.x = 100;

		System.out.println(ob1.x + " " + ob1.y);
		System.out.println(ob2.x + " " + ob2.y);
	}
}
```

**Output:**

```
10 20
10 20
100 20
```

 **Usage of clone() method -Shallow Copy**

```java
package com.gs.corejava.collections;

//A Java program to demonstrate shallow copy 
//using clone() 

//An object reference of this class is 
//contained by Test2 
class Test {
	int x, y;
}

// Contains a reference of Test and implements
// clone with shallow copy.
class Test2 implements Cloneable {
	int a;
	int b;
	Test c = new Test();

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

// Driver class
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;

		// Creating a copy of object t1 and passing it to t2
		Test2 t2 = (Test2) t1.clone(); 
		
		// Change in primitive type of t2 will not  be reflected in t1 field
		t2.a = 100;

		// Change in object type field will be reflected in both t2 and t1(shallow copy)
		t2.c.x = 300;

		System.out.println(t1.a + " " + t1.b + " " + t1.c.x + " " + t1.c.y);
		System.out.println(t2.a + " " + t2.b + " " + t2.c.x + " " + t2.c.y);
	}
}
```

**Output:**

```
10 20 300 40
100 20 300 40
```

In the above example, t1.clone returns the shallow copy of the object t1. To obtain a deep copy of the object certain modifications have to be made in clone method after obtaining the copy.

**Deep Copy vs Shallow Copy**

* **Shallow copy** is method of copying an object and is followed by default in cloning. In this method the fields of an old object X are copied to the new object Y. While copying the object type field the reference is copied to Y i.e object Y will point to same location as pointed out by X. If the field value is a primitive type it copies the value of the primitive type.
* Therefore, any changes made in referenced objects in object X or Y will be reflected in other object.

*Shallow copies are cheap and simple to make. In above example, we created a shallow copy of object.*

**Usage of clone() method – Deep Copy**

* If we want to create a deep copy of object X and place it in a new object Y then new copy of any referenced objects fields are created and these references are placed in object Y. This means any changes made in referenced object fields in object X or Y will be reflected only in that object and not in the other. In below example, we create a deep copy of object.
* A deep copy copies all fields, and makes copies of dynamically allocated memory pointed to by the fields. A deep copy occurs when an object is copied along with the objects to which it refers.

```java
package com.gs.corejava.collections;

//A Java program to demonstrate deep copy 
//using clone() 

//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 refernce variable t
		Test2 t = (Test2) super.clone();

		// Create a new object for the field c
		// and assign it to shallow copy obtained,
		// to make it a deep copy
		t.c = new Test();

		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();
		// Change in primitive type of t2 will not
		// be reflected in t1 field
		t3.a = 100;


		// Change in object type field of t2 will not
		// be reflected in t1(deep copy)
		t3.c.x = 300;

		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);
	}
}
```

**Output:**

```
10 20 30 40
100 20 300 0
```

### Cloning with inheritance (Shallow) :

#### Example 1:

```java
package com.gs.corejava.collections;

//: appendixa:HorrorFlick.java
//You can insert Cloneability at any level of inheritance.
//From 'Thinking in Java, 3rd ed.' (c) Bruce Eckel 2002
//www.BruceEckel.com. See copyright notice in CopyRight.txt.

class Person {
}

class Hero extends Person {
}

class Scientist extends Person implements Cloneable {
	public Object clone() {
		try {
			return super.clone();
		} catch (CloneNotSupportedException e) {
			// This should never happen: It's Cloneable already!
			throw new RuntimeException(e);
		}
	}
}

class MadScientist extends Scientist {
}

public class HorrorFlick {
	public static void main(String[] args) {
		Person p = new Person();
		Hero h = new Hero();
		Scientist s = new Scientist();
		MadScientist m = new MadScientist();
		// ! p = (Person)p.clone(); // Compile error
		// ! h = (Hero)h.clone(); // Compile error
		s = (Scientist) s.clone();
		System.out.println(m.clone().getClass());
		m = (MadScientist) m.clone();
	}
} // /:~

```

#### Example 2:

```java
package com.gs.corejava.collections;

class A implements Cloneable {
	@Override
	protected A clone() throws CloneNotSupportedException // could be public
	{
		Object clone = super.clone();
		System.out.println("Class A: " + clone.getClass()); // will print 'C'
		return (A) clone;
	}
}

class B extends A {
	@Override
	protected B clone() throws CloneNotSupportedException {
		A clone = super.clone();
		System.out.println("Class B: " + clone.getClass()); // will print 'C'
		return (B) clone;
	}
}

class C extends B {
	@Override
	protected C clone() throws CloneNotSupportedException {
		B clone = super.clone();
		System.out.println("Class C: " + clone.getClass()); // will print 'C'
		return (C) clone;
	}
}

public class TestI {

	public static void main(String argv[]) {
		C c = new C();
		try {
			A cloned_c = c.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
```

**Output:**

```
Class A: class com.gs.corejava.collections.C
Class B: class com.gs.corejava.collections.C
Class C: class com.gs.corejava.collections.C
```