以前也用过这个接口，那时是直接所有的东西都自己写了，也没发现问题。最近无意间发现这个接口的实现并不是想象中的那样，所以稍微研究了下，给大家分享一下。

步骤：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 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 getList() {

return list;

}

public void setList(List 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 list = new ArrayList();

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、对于深复制来说，克隆出来的对象不但跟原始对象不一样(地址不一样)，而且内部应用对象也不一样了(地址不一样)