由于在线程安全中涉及到对象的深度拷贝（Deep Copy），很早以前听说多，不多是TypeScript中听一个同事介绍，但是自己对java这块的知识还不了解，于是就打算借此机会学一下深浅拷贝，并加深一下相关技术的印象。于是查阅了一些资料，现将知识点整理如下归为以下几类进行整理：
- 借用图形展示深浅拷贝的区别及特点
- Object类中clone（）方法实现深浅拷贝
- 实际应用中深浅拷贝的区别
- 其他扩展知识
一、 图形表述深浅拷贝的区别和特点
1. 再回顾内存表示示意图
我记得我在Java堆栈介绍介绍中详细介绍了Java的堆、栈及其他们在JVM中的存在形式，再次回顾时，更加清晰，先了解下图，会对理解后续介绍有所帮助。
讨论深浅拷贝的前提
深浅拷贝基本上都是讨论引用类型对象的变量（类的对象，String类等），对于基本数据类型的变量，深浅拷贝都是要复制的。用下图介绍深浅拷贝的区别（图片来源：https://blog.csdn.net/qq_32252957/article/details/82782249）：
先介绍几点概念便于理解：
- 对象（存放在图一中的堆区，一般空间较大）的复制：在堆中单独开辟一块地址空间，用于存放与该对象内容完全相同的一个对象，地址是不同的；
- 对象内部可能包含很多成员变量，这些成员变量又指向不同的对象，所以大部分对象是由很多其他对象组合而成的（一般情况下）。
浅拷贝：只复制当前对象，对该对象内部的引用不能复制。
深拷贝：对对象内部所有对象的引用均复制，每个引用对象创建一个实例并复制实例。
也就是说，他们主要区别在于复制对象本身时是否进一步递归复制子对象。
二、Object类中的clone（）方法实现深浅拷贝及相关注意事项
java内存模型
在开始已经很浅显、简略的介绍了内存模型，更详细的可以看一下JVM（能力有限，作者看了一遍有些地方还是未懂，需要进一步积累再返看，不过好处是对有些内容进一步加深了理解）。这里只介绍内存模型中的堆和栈。
- 栈：存放基本类型的变量数据、局部变量、和对象的引用，但对象本身是放在堆中的（new 出来的对象）或者常量池中（目前接触的好像只有**字符串常量对象）！！！！
- 堆：用来存放new产生的对象数据，数组。这里有一点特别注意：创建出来的对象只包含属于各自的成员变量，并不包括成员方法。因为同一个类的对象拥有各自的成员变量，存储在各自的堆中，但是他们共享该类的方法，并不是创建一个对象就把成员方法复制一次。（作者可算更明白了JVM为什么搞一个方法区，当初看的真的很晦涩难懂，自己又不想死记硬背……）。
“==” 和equals()的区别
以下几点细节仔细思考*****************
- 对于基本数据类型(int,float,double,byte,short,long,boolean,char)，只能用==
- 对于基本数据类型的封装类(Boolean,Integer,Long,Float,Double)，==比较的是指向对象的地址，比较的是栈内存中存放的对象的引用（地址），equals比较的是值。（这个也好理解，包装类还是一般的类！）
- 如果是类对象，那么在对象的类没有重写equals()方法时，==和equals都是比较地址。如果覆盖了equals()方法，根据实际情况比较。
- String类，Data类都重写了equals方法，所以比较地址，equals比较值。（String倒是亲身体验过，Data类倒还没有深入研究过，String的是根据对象来比较的，比较特殊的一种对象）
clone()方法的使用
Java中父类java.lang.Object提供了clone()方法，但考虑到安全性问题，一方面将clone()方法的访问级别设置为protected类型，限制外部类访问，另一方面，强制需要提供clone功能的子类实现java.lang.Cloneable接口。总结就是如果一个类需要被克隆，该类需要实现clone方法和实现Cloneable接口，缺一不可
在java中使用clone()方法如何判别深浅拷贝呢，就是判断拷贝后的对象是否相等，即判断两对象的地址是否相同。B=clone(A),AB为真否。以下图为例：p1是对象1的引用变量，对象1含有对对象2和对象3的引用；p2是p1的clone()。执行p1.对象1p2.对象1（这里需要注意一下，这种表示实际比较的是两个引用指向的对象2是否相等，容易看成指向对象1）为ture，因为他们共同保存对象2的引用。p1==p2为false,因为指向不同的地址。
下面从三个角度说明clone()如何体现深浅拷贝。
对象自身的复制
Clone()方法只复制当前对象，对于没有内部引用的对象，p2克隆p1后，两个对象指向不同的地址，p1==p2操作返回false。如下图：
示例代码：
package clone;
class Person implements Cloneable{ // 实现Cloneable接口
int age;
String name;
public Person(int a, String b){
age=a;
name=b;
}
public Person(Person p){ // 用一个对象来构造另一个对象
this.age=p.age;
this.name=p.name;
}
@Override
public Object clone() {
Person per=null;
try {
per=(Person)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return per;
}
}
public class Body {
public static void main(String[] args){
Person p1=new Person(10,"wang");
Person p2 = (Person) p1.clone();
System.out.println(p1);//输出堆内存的地址
System.out.println(p2);
System.out.println(p2.age);
System.out.println(p1==p2);
}
}
输出：
clone.Person@532760d8
clone.Person@57fa26b7
10
false
这说明clone()之后两对象地址不同，但是值相同。
不含子对象的情况下，浅复制不会clone子对象
当Person类含有其他对象的引用时（含有其他类的对象），增加一个类student，内含成绩grade这个元素，该类对象要作为Person类的成员，添加内部引用。调用clone方法会发现其他对象的引用并没有克隆成功。
如下图：
示例代码：
package clone;
class Student{
String grade;
public Student(){
}
public void setGrade(String a){
this.grade=a;
}
}
class Person2 implements Cloneable{
int age;
String name;
Student grades;
public void setGrades(Student gra){
this.grades=gra;
}
public Person2(int a, String b,Student gra){
age=a;
name=b;
this.grades=gra;
}
public Person2(Person2 p){
this.age=p.age;
this.name=p.name;
}
@Override
public Object clone() {
Person2 per=null;
try {
per=(Person2)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return per;
}
}
public class Body2 {
public static void main(String[] args){
Student stu=new Student();
stu.setGrade("100");
Person2 p1=new Person2(10,"wang",stu);
Person2 p2 = (Person2) p1.clone();
System.out.println(p1.grades==p2.grades);
// 检验子对象的值有没有被修改
System.out.println("*******检验子对象的值有没有被修改********");
stu.setGrade("200");
System.out.println(p2.grades.grade);
System.out.println(p1.grades.grade);
}
}
输出：
true
检验子对象的值有没有被修改*
200
200
这说明：
- 浅拷贝没有复制子对象，否则会为子对象单独申请空间创建实例并为其赋相同值；
- 对象1和被复制出来的对象1所指向的子对象是同一个，子对象值一改之后，两个访问到的值都是被改之后的。
重写clone方法，变成深拷贝之后，将复制子对象
下面仔细的重写下clone方法，变成深拷贝，影响到原对象。
示例代码：
package clone;
class Student1 implements Cloneable{
String grade;
public Student1(){
}
public void setGrade(String a){
this.grade=a;
}
public Object clone(){
Student1 stu=null;
try {
stu=(Student1)super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return stu;
}
}
class Person3 implements Cloneable{
int age;
String name;
Student1 grades;
public void setGrades(Student1 gra){
this.grades=gra;
}
public Person3(int a, String b,Student1 gra){
age=a;
name=b;
this.grades=gra;
}
public Person3(Person3 p){
this.age=p.age;
this.name=p.name;
this.grades=p.grades;
}
@Override
public Object clone() {
Person3 per=null;
try {
per=(Person3)super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
per.grades=(Student1)grades.clone();//深拷贝：就是对引用的对象单独拷贝一次哦。
return per;
}
}
public class Body3 {
public static void main(String[] args){
// TODO Auto-generated method stub
Student1 stu=new Student1();
stu.setGrade("100");
Person3 p1=new Person3(10,"wang",stu);
Person3 p2 = (Person3) p1.clone();
System.out.println(p1.grades==p2.grades);
// 检验子对象的值有没有被修改
System.out.println("*******检验子对象的值有没有被修改********");
stu.setGrade("200");
System.out.println(p2.grades.grade);
System.out.println(p1.grades.grade);
}
}
输出
false
检验子对象的值有没有被修改*
100
200
这说明：
- 可以通过重写clone方法实现深度复制的实现；
- 执行结果为200和100，说明的确不是指向同一个对象了(相同引用)，而是单独指向，不再一变全变。
实际应用中深浅拷贝的区别
- 如果拆开来对对象2的元素依次赋值，这样的肯定就是深度复制了。例如p2.grades=new Student(){}因为这样是明显的创建新实例来进行赋值，没有传递引用等操作。
- Person a2=a1;//最显而易见的浅复制，全是引用，只是用另一个引用指向同一块地址。
其他知识的扩展
本来想借此机会总结下：不一定要通过构造器创建对象这个命题！比如这里的clone（）方法，但是有点多，也比较晚了，留个连接供自己学习和分享。Java之deep copy(深复制)