原创文章，转载请标注出处：https://www.cnblogs.com/V1haoge/p/10755377.html
一、概述
Java中的拷贝功能是由Object类的clone方法定义的。
public class Object{
//...
protected native Object clone() throws CloneNotSupportedException;
//...
}
这是一个可被重写的本地方法。
这个方法是与Cloneable接口相关联的，如果针对一个没有实现Cloneable接口的方法执行器clone方法，会抛出CloneNotSupportedException异常。
二、Cloneable
Cloneable接口就是一个标记接口，表示实现了该接口的类具备了可以克隆的功能。
一般来说，如果一个类实现了该接口，那么同时需要重写Object中的clone方法。
这里要谨记一点：clone方法是Object中定义的方法，而不是Cloneable中定义的，后者只是一个标记接口，其中没有任何方法定义。
三、clone()
当一个类实现了Cloneable之后，具备了可被克隆的基础条件，下面就需要具体完善克隆工作的细节了。
细节当然需要依靠重写clone方法来实现。
到这里就涉及到了本文的重点：浅拷贝与深拷贝。
简单说下二者的区别：
浅拷贝就是克隆出来的新对象与原对象完全一致无二，包括引用类型字段的值。这就会有一个现象，针对引用类型的字段，两个对象的引用地址一致，如此一来新旧对象之间强关联，修改其中一个对象的内容，极可能影响到另外一个的内容。
深拷贝是针对浅拷贝而言的，那就是将所有引用的对象同样做深拷贝，这样一来，新旧对象就不再强关联，当我们修改其中一个对象时，不会影响到另外一个。
3.1 浅拷贝
实现浅拷贝非常简单，直接调用Object中定义的clone方法即可。也即，Object中定义的clone方法实现的是浅拷贝功能。
让我们来看看下面的例子：
class A {
int i = 20;
A(){}
A(int i){
this.i = i;
}
}
class B implements Cloneable{
private int i = 10;
private A a = new A(11);
public Object clone () {
B b = null;
try {
b = (B)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return b;
}
public A getA() {
return a;
}
public void setA(A a) {
this.a = a;
}
}
public class CloneTest {
public static void main(String[] args) {
B b1 = new B();
// 执行浅拷贝
System.out.println("执行浅拷贝：");
B cb1 = (B)b.clone();
System.out.println(cb1.equals(b));// false-表示clone的对象与原对象不同
System.out.println((cb1.getA()).equals(b.getA()));// true-表示浅拷贝引用对象不变
}
}
执行结果为：
执行浅拷贝：
false
true
通过实例我们可以看出，要写实现浅拷贝需要如下几步：
- 被拷贝对象的类实现Cloneable接口
- 被拷贝对象的类重写Object的clone方法
- 执行拷贝操作，就是调用重写的clone方法来完成克隆
从实例的执行结果中可以看出新的clone对象实例cb1与原对象实例b1，之间equals不等，这里的equals比较的是两个对象的地址，与“==”效果一致。而cb1的a字段指向的A实例与b1的a字段指向的A实例却是一样的，这就是浅拷贝。
浅拷贝是浅层拷贝，只在意目标对象一个，与其关联的其他对象一概不管。
但是在实际使用中，使用浅拷贝的情况很少，多数情况下，我们需要的是一个完全崭新的对象，包括它的字段引用，那么我们就需要实现深拷贝了。
3.2 深拷贝
所谓深拷贝就是相对浅拷贝而言的，在浅拷贝的基础上进一步进行深层拷贝即可，那么具体实现呢？
class A implements Cloneable{
int i = 20;
A(){}
A(int i){
this.i = i;
}
public Object clone (){
A a = null;
try {
a = (A)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return a;
}
}
class B implements Cloneable{
private int i = 10;
private A a = new A(11);
public Object clone () {
B b = null;
try {
b = (B)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return b;
}
public A getA() {
return a;
}
public void setA(A a) {
this.a = a;
}
}
public class CloneTest {
public static void main(String[] args) {
B b = new B();
// 执行浅拷贝
System.out.println("执行浅拷贝：");
B cb1 = (B)b.clone();
System.out.println(cb1.equals(b));// false-表示clone的对象与原对象不同
System.out.println((cb1.getA()).equals(b.getA()));// true-表示浅拷贝引用对象不变
// 执行深拷贝
System.out.println("----------------");
System.out.println("执行深拷贝：");
B cb2 = (B)b.clone();
A ca = (A)b.getA().clone();
cb2.setA(ca);
System.out.println(cb2.equals(b));// false-表示clone的对象与原对象不同
System.out.println((cb2.getA()).equals(b.getA()));// true-表示浅拷贝引用对象不变
}
}
执行结果：
执行浅拷贝：
false
true
----------------
执行深拷贝：
false
false
通过实例我们可以清楚看出，要想实现深拷贝需要如下几步：
- 被拷贝的目标对象的类的依赖对象的类A需要实现Cloneable接口
- 类A需要重写Object的clone方法
- 在b拷贝完成后，要继续执行b中被依赖对象a的拷贝，并将拷贝结果赋值给b的拷贝对象。
可见深拷贝其实就是一个递归拷贝的过程，将目标对象的类依赖的所有对象的类全部实现Cloneable接口并重写clone方法进行二层拷贝，然后是依赖对象的依赖对象...层层深入拷贝。
四、注意事项
Java中提供的类中存在一些无法被clone的类，比如StringBuffer，它既没有实现Cloneable接口，也没有重写clone方法，那么它就无法执行克隆操作，那么遇到它该怎么办呢？
这里提供一种办法，既然是新对象，那么直接创建一个新的StringBuffer对象，将原来的值赋值进来，就等于是完成了克隆，虽然这种方式要比Object中的clone方法慢许多，但不失为一种补救措施。
还有一些类型如基本类型的装箱类型、String，它们虽然也是引用类型，但是它们是final修饰的，且没有实现Cloneable接口，没有重写clone方法，要克隆也需要采用上面所示的方式来实现。
参考：