探讨Java中浅拷贝与深拷贝的区别

• 前言
• 一、clone()
• 二、浅拷贝
• 三、深拷贝
• 四、clone()的替换方案

clone()是Object的protected方法，它不是public的，一个类不显式去重写clone()，其它类就不能直接去调用该类实例的clone()方法。

举例说明：

public class CloneExample {
	private int i;
	private int j;
	// 构造器
	public CloneExample() {
	}
}

	CloneExample e1 = new CloneExample();
	// CloneExample e2 = e1.clone(); 
	// 'clone()'has protected access in 'java.lang.Object'

重写clone()方法得到以下实现：

public class CloneExample {
	private int i;
	private int j;
	
	@Override
	protected CloneExample clone() throws CloneNotSupportedException {
		return (CloneExample) super.clone();
	}
 }

	CloneExample e1 = new CloneExample();
	try {
		CloneExample e2 = e1.clone(); 
	} catch(CloneNotSupportedException e) {
		e.printStackTrace();
	}

Exception: java.lang.CloneNotSupportedException

以上抛出了CloneNotSupportedException，这是因为CloneExample没有实现Cloneable接口。

应该注意的是，clone()方法并不是Cloneable的方法，而是Object的一个protected方法。Cloneable接口只是规定：如果一个类没有实现Cloneable接口又调用了clone()方法，就会抛出CloneNotSupportedException异常。

拷贝对象和原始对象的引用类型引用同一个对象。

public class ShallowCopyExample implements Cloneable {
	private int[] arr;
	
	public ShallowCopyExample() {
		arr = new int[10];
		for (int i = 0 ; i < arr.length; i++) {
			arr[i] = i;
		}
	}	
	
	public void set(int index, int value) {
		arr[index] = value;
	}

	public int get(int index) {
		return arr[index];
	}
	
	@Override
	protected ShallowCopyExample clone() throws CloneNotSupportedException {
		return (ShallowCopyExample)super.clone();
	}
}

	ShallowCopyExample sce1= new ShallowCopyExample();
	ShallowCopyExample sce2= null;
	try {
		sce2= sce1.clone();
	} catch (CloneNotSupportedException e) {
		e.printStackTrace();	
	}
	sce1.set(3, 23);
	System.out.prinln(sce2.get(3)); // output：23

Object 类的 clone 方法返回的对象独立于正被复制的对象。要获得此独立性，在 super.clone 返回对象之前，有必要对该对象的一个或多个字段进行修改。这通常意味着要复制包含正在被复制对象的内部“深层结构”的所有可变对象，并使用对副本的引用替换对这些对象的引用。如果一个类只包含基本字段或对不变对象的引用，那么通常不需要修改 super.clone 返回的对象中的字段。

注意：
1、浅拷贝对象与原始对象并不相等，因为clone的过程是创建并返回原始对象的一个副本；
2、浅拷贝对象与原始对象中引用类型的引用不变，被引用对象本身可以修改。
3、风险比较大，两者是相互依赖的关系。

拷贝对象和原始对象的引用类型引用不同对象

public class DeepCopyExample implements Cloneable {
	private int[] arr;
	
	public DeepCopyExample () {
		arr = new int[10];
		for (int i = 0 ; i < arr.length; i++) {
			arr[i] = i;
		}
	}	
	
	public void set(int index, int value) {
		arr[index] = value;
	}

	public int get(int index) {
		return arr[index];
	}
	
	@Override
	protected DeepCopyExample clone() throws CloneNotSupportedException {
		DeepCopyExample dce = (DeepCopyExample) super.clone();
		result.arr = new int[arr.length];
		for (int i = 0 ; i < arr.length; i++) {
			dce.arr[i] = arr[i];
		}
		return dce;
	}

	DeepCopyExample dce1 = new DeepCopyExample();
	DeepCopyExample dce2 = null;
	try {
		dce2= dce1.clone();
	} catch (CloneNotSupportedException e) {
		e.printStackTrace();	
	}
	dce1.set(3, 23);
	System.out.prinln(dce2.get(3)); // output：3
	

深拷贝建立在浅拷贝的基础之上，在clone()的过程中，引用类型的引用指向了新的对象，对象本身的内容进行了复制。深拷贝对象与原始对象是相互独立的关系。

使用clone()方法来拷贝一个对象即复杂又有风险，不仅可能会抛出异常，还需要类型转换。Effective Java书上提到，最好不要使用clone()，而是使用拷贝构造器或者拷贝工厂来拷贝一个对象。

public class CopyConstructorExample implements Cloneable {
	private int[] arr;
	
	public CopyConstructorExample () {
		arr = new int[10];
		for (int i = 0 ; i < arr.length; i++) {
			arr[i] = i;
		}
	}	
	
	public CopyConstructorExample (CopyConstructorExample original) {
		arr = new int[original.arr.length];
		for (int i = 0 ; i < original.arr.length; i++) {
			arr[i] = original.arr[i];
		}
	}	

	public void set(int index, int value) {
		arr[index] = value;
	}

	public int get(int index) {
		return arr[index];
	}
}

	CopyConstructorExample cce1 = new CopyConstructorExample();
	CopyConstructorExample cce2 = new CopyConstructorExample(cce1);
	cce1.set(3, 23);
	System.out.prinln(cce2.get(3)); // output：3