这是我参与8月更文挑战的第22天，活动详情查看：8月更文挑战
概念
直接赋值
直接赋值是我们最常用的方式，是一种简单明了的方式，但是它只是拷贝了对象引用地址而已，并没有在内存中生成新的对象
浅复制（浅拷贝）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
深复制（深拷贝）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。
那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。
换言之，深复制把要复制的对象所引用的对象都复制了一遍。
拷贝的引入
（1）、引用拷贝
创建一个指向对象的引用变量的拷贝。
Teacher teacher = new Teacher("Taylor",26);
Teacher otherteacher = teacher;
System.out.println(teacher);
System.out.println(otherteacher);
输出结果：
blog.Teacher@355da254
blog.Teacher@355da254
（2）、对象拷贝
创建对象本身的一个副本。
Teacher teacher = new Teacher("Swift",26);
Teacher otherteacher = (Teacher)teacher.clone();
System.out.println(teacher);
System.out.println(otherteacher);
输出结果：
blog.Teacher@355da254
blog.Teacher@4dc63996
浅拷贝代码实现
还以上文的例子来讲，我想通过student1拷贝得到student2，浅拷贝的典型实现方式是：让被复制对象的类实现Cloneable接口，并重写clone()方法即可。
以上面的Student类拷贝为例：
public class Student implements Cloneable {
private String name; // 姓名
private int age; // 年龄
private Major major; // 所学专业
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
// ... 其他省略 ...
}
然后我们写个测试代码，一试便知：
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
Major m = new Major("计算机科学与技术",666666);
Student student1 = new Student( "CodeSheep", 18, m );
// 由 student1 拷贝得到 student2
Student student2 = (Student) student1.clone();
System.out.println( student1 == student2 );
System.out.println( student1 );
System.out.println( student2 );
System.out.println( "\n" );
// 修改student1的值类型字段
student1.setAge( 35 );
// 修改student1的引用类型字段
m.setMajorName( "电子信息工程" );
m.setMajorId( 888888 );
System.out.println( student1 );
System.out.println( student2 );
}
}
从结果可以看出：
student1==student2打印false，说明clone()方法的确克隆出了一个新对象；- 修改值类型字段并不影响克隆出来的新对象，符合预期；
- 而修改了
student1内部的引用对象，克隆对象student2也受到了波及，说明内部还是关联在一起的
深拷贝代码实现
1.实现 Cloneable 接口方式
package com.test;
public class DeepCopy {
public static void main(String[] args) throws CloneNotSupportedException {
Teacher2 teacher = new Teacher2();
teacher.setName("riemann");
teacher.setAge(27);
Student3 student1 = new Student3();
student1.setName("edgar");
student1.setAge(18);
student1.setTeacher(teacher);
Student3 student2 = (Student3) student1.clone();
System.out.println("拷贝后");
System.out.println(student2.getName());
System.out.println(student2.getAge());
System.out.println(student2.getTeacher().getName());
System.out.println(student2.getTeacher().getAge());
System.out.println("修改老师的信息后-------------");
// 修改老师的信息
teacher.setName("Games");
System.out.println(student1.getTeacher().getName());
System.out.println(student2.getTeacher().getName());
}
}
class Teacher2 implements Cloneable {
private String name;
private int age;
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;
}
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Student3 implements Cloneable {
private String name;
private int age;
private Teacher2 teacher;
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;
}
public Teacher2 getTeacher() {
return teacher;
}
public void setTeacher(Teacher2 teacher) {
this.teacher = teacher;
}
public Object clone() throws CloneNotSupportedException {
// 浅复制时：
// Object object = super.clone();
// return object;
// 改为深复制：
Student3 student = (Student3) super.clone();
// 本来是浅复制，现在将Teacher对象复制一份并重新set进来
student.setTeacher((Teacher2) student.getTeacher().clone());
return student;
}
}
输出结果：
拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
riemann
结果分析：
两个引用student1和student2指向不同的两个对象，两个引用student1和student2中的两个teacher引用指向的是两个对象，但对teacher对象的修改只能影响student1对象,所以说是深拷贝。
2.实现 Serializable 接口方式
实现 Serializable 接口方式也可以实现深拷贝，而且这种方式还可以解决多层克隆的问题，多层克隆就是引用类型里面又有引用类型，层层嵌套下去，用 Cloneable 方式实现还是比较麻烦的，一不小心写错了就不能实现深拷贝了，使用 Serializable 序列化的方式就需要所有的对象对实现 Serializable 接口，我们对代码进行改造，改造成序列化的方式
public class Person implements Serializable {
private static final long serialVersionUID = 369285298572941L;
// 姓名
private String name;
// 年龄
private int age;
// 邮件
private String email;
private PersonDesc personDesc;
public Person clone() {
Person person = null;
try { // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
// 将流序列化成对象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
person = (Person) ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return person;
}
public void setDesc(String desc) {
this.personDesc.setDesc(desc);
}
...省略...
}
public class PersonDesc implements Serializable {
private static final long serialVersionUID = 872390113109L;
// 描述
private String desc;
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
}
public class PersonApp {
public static void main(String[] args) throws Exception {
// 初始化一个对象
Person person = new Person("平头",20,"123456@qq.com","技术");
// 复制对象
Person person1 = (Person) person.clone();
// 改变 person1 的属性值
person1.setName("我是平头的克隆对象");
// 修改 person age 的值
person1.setAge(22);
person1.setDesc("我已经关注了技术");
System.out.println("person对象："+person);
System.out.println();
System.out.println("person1对象："+person1);
}
}
