以前也用过这个接口，那时是直接所有的东西都自己写了，也没发现问题。最近无意间发现这个接口的实现并不是想象中的那样，所以稍微研究了下，给大家分享一下。
步骤：1、建立两个简单的POJO:Teacher和Student
2、Teacher类实现了Cloneable接口，重写clone方法
3、在main方法中建立teacher，然后clone,比较teacher和clone出来的teacher
Teacher类：
public class Teacher implements Cloneable,Serializable{
private String name;
private String sex;
private int age;
private List<Student> list;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public List<Student> getList() {
return list;
}
public void setList(List<Student> list) {
this.list = list;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
protected Teacher clone() throws CloneNotSupportedException {
Teacher t = (Teacher)super.clone();
return t;
}
public Teacher deepClone() throws IOException, ClassNotFoundException
{
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream temp_out = new ObjectOutputStream(out);
temp_out.writeObject(this);
ByteArrayInputStream input = new ByteArrayInputStream(out.toByteArray());
ObjectInputStream temp_input = new ObjectInputStream(input);
return (Teacher) temp_input.readObject();
}
}
Student类：
public class Student implements Serializable{
private String stName;
private String stSex;
public String getStName() {
return stName;
}
public void setStName(String stName) {
this.stName = stName;
}
public String getStSex() {
return stSex;
}
public void setStSex(String stSex) {
this.stSex = stSex;
}
}
main：
public class MainTest {
public static void main(String[] args) throws CloneNotSupportedException, ClassNotFoundException, IOException {
List<Student> list = new ArrayList<Student>();
Student st = new Student();
st.setStName("stname");
st.setStSex("f");
list.add(st);
Teacher te = new Teacher();
te.setAge(19);
te.setList(list);
te.setName("tename");
te.setSex("tesex");
Teacher cl = te.clone();
cl.setAge(12);
System.out.println("淺複製"+ (cl == te));
//内存中的地址
System.out.println(cl.getName() == te.getName());
System.out.println(cl.getList() == te.getList());
System.out.println("source:"+te.getAge()+"<==>clone:"+cl.getAge());
Teacher deep = te.deepClone();
System.out.println("深複製"+(cl == te));
System.out.println(deep.getName() == te.getName());
System.out.println(deep.getList() == te.getList());
}
}
输出结果：
淺複製false
true
true
source:19<==>clone:12
深複製false
false
false
从输出结果可以得出的结论：
1、对于浅复制来说，当调用clone方法返回的cl对象跟te对象不是同一个对象（地址不一样），但是内部的对象引用却是引用的相同对象（地址一样）；而对于基本类型age（int）来说，克隆的对象cl跟原始对象te不是同一个（如果是同一个的话，修改任何一个，另外对象的内容也会变化）
2、对于深复制来说，克隆出来的对象不但跟原始对象不一样（地址不一样），而且内部应用对象也不一样了（地址不一样）