1.浅复制
如果说引用类型复制的是引用，基本类型复制的是值，这么说是不严谨的，因为String也是引用类型（或者说String类型复制的是值，不知道为什么会这样，难道因为String是不可变类型？？？）
Student类和Teacher类后面都有
需要注意的是浅拷贝是在Teacher类中重写Object类的clone()方法（因为Teacher类中没有clone方法），实际上是调用Object类的clone()方法
public Object clone() {
try {
return super.clone();
}catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
2.深复制（有两种方式）
方式一：重写clone()方法
在Student类中增加：
在Teacher类中增加：
这么写的话，仍然只会复制数组类的引用
结果为：
只有Student类实现了深复制，数组复制的仍然是引用，若要不改变原数组的值，应该修改Teacher类中的clone()方法为：
结果为：
由上可知，重写clone()方法比较麻烦，若一个类中有几百个引用变量，那么必须都得重写，因此较麻烦
方式二：反序列化
只需让Student类和Teacher类都实现Serializable接口（Serializable是一个空接口），否则会报异常
然后在Teacher类中增加：
结果为：
发现要方便的多。
1、Student类：
class Student implements Cloneable,Serializable{
private String name;
private int age;
@Override
public String toString() {
return "Student{" +
"name='" +name +'\'' +
", age=" +age +
'}';
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public StringgetName() {
return name;
}
public int getAge() {
return age;
}
}
2.Teacher 类（实现了Cloneable接口，Cloneable是空接口，必须实现该接口，否则报异常），重写的clone()方法是Object类的方法，默认是浅复制
如果Teacher 类不实现Cloneable接口，则会：
class Teacher implements Cloneable,Serializable{
private Stringname;
private int age;
private int[] ints;
private Student student;
public Teacher(String name, int age,int[] ints,Student student){
this.name = name;
this.age = age;
this.ints=ints;
this.student=student;
}
public void setStudent(Student student) {
this.student = student;
}
public StudentgetStudent() {
return student;
}
public int[] getInts() {
return ints;
}
public void setInts(int[] ints) {
this.ints = ints;
}
@Override
public Object clone() {
try {
return super.clone();
}catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
