前言：
今天大家对“java浅拷贝的三种实现方式”都比较关心，兄弟们都需要剖析一些“java浅拷贝的三种实现方式”的相关知识。那么小编同时在网上网罗了一些有关“java浅拷贝的三种实现方式””的相关文章，希望大家能喜欢，小伙伴们快快来学习一下吧！前言
拷贝，顾名思义，就是复制一个一模一样的东西。
那么放到对象上，也就是复制一个一模一样的对象了。
Java中的数据类型分为基本数据类型和引用数据类型。对于这两种数据类型，在进行赋值操作、用作方法参数或返回值时，会有值传递和引用（地址）传递的差别。
了解深拷贝和浅拷贝的原理，对于Java中的所谓值传递或者引用传递将会有更深的理解。
注意
下文中的很多代码意义的解释，我都放到代码注释里了，方便大家对照浏览，请仔细阅读代码。
浅拷贝(Shallow Copy)
一、简介
浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制对象资源。
二、特点
1、 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。
基础类型的拷贝，其中一个对象修改该值，不会影响另外一个。
2、对于引用类型，比如数组或者类对象，因为引用类型是引用传递，所以浅拷贝只是把内存地址赋值给了成员变量，它们指向了同一内存空间。改变其中一个，会对另外一个也产生影响。
结构图如下：
上图中可以看出，基本数据类型的成员变量，对其值创建了新的拷贝；而引用数据类型的成员变量的实例仍然是只有一份，两个对象的该成员变量都指向同一个实例。
三、代码实现
核心步骤：
1、实现 Cloneable 接口
2、重写 clone() 方法
/** * @author 头条：技术好奇心 * 学科类 */class Subject{ // 学科名称 private String name; // 构造方法 public Subject(String name) { this.name = name; } // 获取学科名称 public String getName() { return name; } // 设置学科名称 public void setName(String name) { this.name = name; } // 重写toString()方法 @Override public String toString() { return "[科目: " + this.hashCode() + ",名称:" + name + "]"; }}/** * @author 头条：技术好奇心 * 学生类 */class Student implements Cloneable { // 科目对象（引用类型） private Subject subject; // 学生名称 private String name; // 学生年龄 private int age; // 获取学生科目对象 public Subject getSubject() { return subject; } // 设置学生科目 public void setSubject(Subject subject) { this.subject = subject; } // 获取学生姓名 public String getName() { return name; } // 设置学生姓名 public void setName(String name) { this.name = name; } // 获取学生年龄 public int getAge() { return age; } // 设置学生年龄 public void setAge(int age) { this.age = age; } // 重写clone()方法 @Override public Object clone() { //浅拷贝 try { // 直接调用父类的clone()方法 return super.clone(); } catch (CloneNotSupportedException e) { return null; } } @Override public String toString() { return "[学生: " + this.hashCode() + ",科目:" + subject + ",姓名:" + name + ",年龄:" + age + "]"; }}/** * @author 头条：技术好奇心 * 浅拷贝实现类 */public class ShallowCopy{ public static void main(String[] args) { // 创建语文对象 Subject subjectA = new Subject("语文"); // 创建学生对象A Student studentA = new Student(); // 给学生A设置语文科目 studentA.setSubject(subjectA); // 给学生A取名张三 studentA.setName("张三"); // 给学生A设定年龄为20岁 studentA.setAge(20); // 通过clone()方法直接以克隆学生对象A的方式创建学生对象B Student studentB = (Student) studentA.clone(); // 给学生B取名李四 studentB.setName("李四"); // 给学生B设定年龄为18岁 studentB.setAge(18); // 尝试在未具体设置学生B科目的情况下，直接获取其科目对象 Subject subjectB = studentB.getSubject(); // 重新给科目B对象设置科目名称 subjectB.setName("数学"); // ------------ 来看看现在学生A和学生B两个对象中的具体值 ------------------ System.out.println("studentA:" + studentA.toString()); System.out.println("studentB:" + studentB.toString()); }}运行结果：
studentA:[学生: 460141958,科目:[科目: 1163157884,名称:数学],姓名:张三,年龄:20]studentB:[学生: 1956725890,科目:[科目: 1163157884,名称:数学],姓名:李四,年龄:18]
从上面运行结果可以看出，通过 studentA.clone() 拷贝对象后得到的 studentB，和 studentA 是两个不同的对象。studentA 和 studentB 的基础数据类型的修改互不影响，而引用类型 subject 修改后是会有影响的。
深拷贝(Deep Copy)
一、简介
深拷贝，在拷贝引用类型成员变量时，为引用类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝。
从而解决了上面浅拷贝修改科目B会影响科目A的安全隐患。
二、特点
1、对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）。
2、对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。
3、对于有多层对象的，每个对象都需要实现 Cloneable 并重写 clone() 方法，进而实现了对象的串行层层拷贝。
4、深拷贝相比于浅拷贝速度较慢并且花销较大。
结构图如下：
上图一目了然，对象克隆后，没有任何关联，是完全独立的两部分。
三、代码实现
/** * @author 头条：技术好奇心 * 科目类 - 需要实现 Cloneable 并重写 clone() 方法。 */class DeepSubject implements Cloneable{ // 科目名称 private String name; // 构造方法 public DeepSubject(String name) { this.name = name; } // 获取科目名称 public String getName() { return name; } // 设置科目名称 public void setName(String name) { this.name = name; } // 重写clone()方法 @Override protected Object clone() throws CloneNotSupportedException { //Subject 如果也有引用类型的成员属性，也应该和 Student 类的clone()方法一样通过其引用类型成员的实现（具体参见下面Student类） return super.clone(); } // 重写toString()方法 @Override public String toString() { return "[科目: " + this.hashCode() + ",名称:" + name + "]"; }}/** * @author 头条：技术好奇心 * 学生类 */class DeepStudent implements Cloneable { // 学科名称（引用类型） private DeepSubject subject; // 学生姓名 private String name; // 学生年龄 private int age; // 获取该学生的学科对象 public DeepSubject getSubject() { return subject; } // 设置学生学科 public void setSubject(DeepSubject subject) { this.subject = subject; } // 获取学生姓名 public String getName() { return name; } // 设置学生姓名 public void setName(String name) { this.name = name; } // 获取学生年龄 public int getAge() { return age; } // 设置学生年龄 public void setAge(int age) { this.age = age; } /** * 重写clone()方法 * @return */ @Override public Object clone() { //深拷贝 try { // 直接调用父类的clone()方法拷贝自己 DeepStudent student = (DeepStudent) super.clone(); // 通过对新的对象(student)的引用类型再调用拷贝操作，实现对引用类型成员变量 subject的深拷贝 student.subject = (DeepSubject) subject.clone(); return student; } catch (CloneNotSupportedException e) { return null; } } @Override public String toString() { return "[学生: " + this.hashCode() + ",科目:" + subject + ",姓名:" + name + ",年龄:" + age + "]"; }}public class DeepCopy{ public static void main(String[] args) { // 新建学科A语文 DeepSubject subjectA= new DeepSubject("语文"); // 新建学生A DeepStudent studentA = new DeepStudent(); // 设置学生A的学科为语文 studentA.setSubject(subjectA); // 给学生A取名王五 studentA.setName("王五"); // 给学生A设定年龄为19 studentA.setAge(19); // 通过克隆学生A对象的方式创建学生B对象 DeepStudent studentB = (DeepStudent) studentA.clone(); // 设定学生B姓名为赵六 studentB.setName("赵六"); // 设置学生B的年龄为18 studentB.setAge(18); // 同样的，这里也没有设置学生B的学科，直接获取B的学科对象 DeepSubject subjectB = studentB.getSubject(); // 将其学科对象设置为数学 subjectB.setName("数学"); // ---------------------- 这里我们再来看看，他与浅拷贝打印的区别 -------------------- System.out.println("studentA:" + studentA.toString()); System.out.println("studentB:" + studentB.toString()); }}运行结果：
studentA:[学生: 460141958,科目:[科目: 1163157884,名称:语文],姓名:王五,年龄:19]studentB:[学生: 1956725890,科目:[科目: 356573597,名称:数学],姓名:赵六,年龄:18]
看到没有，这里很明显，学生B设置自己的科目并没有对学生A产生影响。
由此可见，深拷贝后，不管是基础数据类型还是引用类型的成员变量，修改其值都不会相互造成影响。
标签： #java浅拷贝的三种实现方式
