写一个简短的开场白吧，最近在深入一些框架的学习，但是感觉有些吃力，甚至怀疑自己到底适不适合当程序员。总而言之，过程很痛苦，用别人造好的轮子感觉爽的飞起，一旦研究别人的轮子，瞬间被秒。既然想成为大神，想成为一个设计轮子的人，这些是必须经历的吧。在获得什么之前，总的付出些什么吧。一句话，死磕到底。
今天第一个关于Java的问题是，对象克隆。
对象克隆
绘图1.jpg
/**
* @ClassName: Student
* @Description: TODO
* @Author: kevin
* @Date: 2019-04-07 01:39
* @Version: 1.0
**/
public class Student implements Cloneable {
private String name;
private Integer age;
private StringBuilder birthday;
public Student(String name, Integer age, StringBuilder birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public StringBuilder getBirthday() {
return birthday;
}
public void setBirthday(StringBuilder birthday) {
this.birthday = birthday;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", birthday=" + birthday +
'}';
}
}
/**
* @ClassName: CloneTest
* @Description: TODO
* @Author: kevin
* @Date: 2019-04-07 01:41
* @Version: 1.0
**/
public class CloneTest {
public static void main(String[] args) {
Student S1 = new Student("A", 18, new Date());
Student S2 = S1;
System.out.println(S1);
System.out.println(S2);
}
}
首先，看完上述内容，可能第一反应就是，这是毛线的克隆。其实这的确不是克隆，这仅仅是一个简单的对象的引用，S1 和 S2 都指向同一个 Student 对象。因此，这两个实例对象中的任何一个修改 Student 中的内容，那么另一个的实例所引用的属性也会发生变化。因为，在内存中本就只有一个 new 出来的Student。
接下来，该克隆了。clone() 方法是Object中的一个protected方法，因此，想要调用 clone() 方法是有前提条件的（这是由protected决定的，因为clone() 方法比较复杂，在设计之初，就为了防止误用，因此加上protected），protected对本包的所有子类可见，很明显，上述中的 Student 类和 clone() 方法不在一同个包中，因此，想要使用它，必须实现 Cloneable 接口，并重写clone()方法。
Cloneable 接口的出现与接口的正常使用没有关系。该接口没有指定clone()方法，这个接口只是作为一个标记，指示类设计者了解克隆过程。（《Java核心技术 卷1》）
/**
* @ClassName: CloneTest
* @Description: TODO
* @Author: kevin
* @Date: 2019-04-07 01:41
* @Version: 1.0
**/
public class CloneTest {
public static void main(String[] args) {
Student student1 = new Student("A", 18, new StringBuilder("1995"));
try {
Student student2 = (Student) student1.clone();
System.out.println(student1);
System.out.println(student2);
student2.setName("B");
student2.setBirthday(student2.getBirthday().append("09"));
System.out.println(student1);
System.out.println(student2);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
================
结果
================
Student{name='A', age=18, birthday=1995}
Student{name='A', age=18, birthday=1995}
Student{name='A', age=18, birthday=199509}
Student{name='B', age=18, birthday=199509}
问题来了，当执行 Student student2 = (Student) student1.clone(); 时，的确 new出新的 Student 对象实例（新开辟了一块区域），并且实例对象的初始状态和之前的保持一致。但是在更改 student2 时，发现连同 student1 的生日一起变了。
绘图2.jpg
图中 Date 类应该为 StringBuilder 类，这两个类都是可变的类。但是，为了方便操作使用 StringBuilder 类
上图就是产生问题的原因，因为 name 和 birthday 共用了一个存储区域（也就是浅拷贝），导致 student2 修改的同时，将 student1 的生日一起修改了。但是这里有个问题，为什么名字没有被一起修改？
- 浅拷贝，如果原对象和克隆对象共享的子对象是不可变的，那么这种克隆就是安全的。
- 本例中，共享子对象有String，StringBuilder，这两个类，其中 String 是被 final 修饰的类，也就是不可变的类，而 StringBuilder 类不是不可变的类，因此在克隆 birthday 时就出现了问题。
- 总结，基本数据类型，不可变类，在浅拷贝时，不会出现任何问题。
原因已经知晓，该怎么解决呢，代码如下
/**
* @ClassName: Student
* @Description: TODO
* @Author: kevin
* @Date: 2019-04-07 01:39
* @Version: 1.0
**/
public class StudentA implements Cloneable {
private String name;
private Integer age;
private StringBuilder birthday;;
public StudentA(String name, Integer age, StringBuilder birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public StringBuilder getBirthday() {
return birthday;
}
public void setBirthday(StringBuilder birthday) {
this.birthday = birthday;
}
@Override
protected StudentA clone() throws CloneNotSupportedException {
StudentA studentA = (StudentA) super.clone();
studentA.birthday = new StringBuilder(birthday);
return studentA;
}
@Override
public String toString() {
return "StudentA{" +
"name='" + name + '\'' +
", age=" + age +
", birthday=" + birthday +
'}';
}
}
注意，在重写 clone() 方法时，把可变类 StringBulider 也进行了一次新的创建，并且初始值仍为克隆前的值，这样就能解决浅拷贝的问题。
实验对比
/**
* @ClassName: CloneTest
* @Description: TODO
* @Author: kevin
* @Date: 2019-04-07 01:41
* @Version: 1.0
**/
public class CloneTest {
public static void main(String[] args) {
Student student1 = new Student("A", 18, new StringBuilder("1995"));
try {
Student student2 = (Student) student1.clone();
System.out.println(student1);
System.out.println(student2);
student2.setName("B");
student2.setBirthday(student2.getBirthday().append("09"));
System.out.println(student1);
System.out.println(student2);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
System.out.println("--------------------");
StudentA studentA1 = new StudentA("A", 18, new StringBuilder("1995"));
try {
StudentA studentA2 = studentA1.clone();
System.out.println(studentA1);
System.out.println(studentA2);
studentA2.setName("B");
studentA2.setBirthday(studentA2.getBirthday().append("09"));
System.out.println(studentA1);
System.out.println(studentA2);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
================
结果
================
Student{name='A', age=18, birthday=1995}
Student{name='A', age=18, birthday=1995}
Student{name='A', age=18, birthday=199509}
Student{name='B', age=18, birthday=199509}
--------------------
StudentA{name='A', age=18, birthday=1995}
StudentA{name='A', age=18, birthday=1995}
StudentA{name='A', age=18, birthday=1995}
StudentA{name='B', age=18, birthday=199509}
参考资料
《Java核心技术 卷1》
