深克隆和浅克隆
为什么需要克隆？
new出来的对象中的属性都是初始化时候的值，当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。直接使用Object a=new Object();Object b;b=a不行吗，答案是不行的。因为这只是克隆了引用。
如何实现克隆？
首先由两种克隆的方式，一个是深克隆，一个是浅克隆。他们之间的区别在于：是否支持引用类型的成员变量的复制，深克隆会克隆引用类型的成员变量。
clone方法来源于Object,我们追本逐源看看：
protected native Object clone() throws CloneNotSupportedException;
可以看出，clone()是Object的native方法，而且还是protected以为着不能再类外进行访问，想要实现克隆方法，只有覆盖这个方法。
public class Student implements Cloneable {
private String name;
private int age;
@Override
protected Object clone() {
Student student=null;
try {
student =(Student) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return student;
}
...
getter and setter
...
public class Test {
public static void main(String[] args){
Student stu1 = new Student("张三",18);
Student stu2 = (Student) stu1.clone();
stu2.setName("李四");
stu2.setAge(20);
System.out.println("stu1:"+stu1.getName()+" age:"+stu1.getAge());
System.out.println("stu2:"+stu2.getName()+" age:"+stu2.getAge());
System.out.println(stu2 == stu1); //false
}
}
stu1:张三 age:18
stu2:李四 age:20
false
上面的案例，属于浅克隆，克隆对象中的属性不包括引用对象，如果包含引用对象，则该引用对象也必须要实现cloneable接口。
public class Student implements Cloneable {
private String name;
private int age;
private Address address; //新增地址对象
@Override
protected Student clone() {
Student stu =null;
try {
stu = (Student) super.clone();
stu.setAddress(address.clone());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return stu;
}
....
public class Address implements Cloneable {
private String add;
//也需要实现clone方法
@Override
protected Address clone() throws CloneNotSupportedException {
return (Address)super.clone();
}
....
}
public class Test {
public static void main(String[] args){
Student stu1 = new Student("张三",18,new Address("上海"));
Student stu2 = (Student) stu1.clone();
stu2.setName("李四");
stu2.setAge(20);
stu1.setAddress(new Address("北京"));
System.out.println("stu1:"+stu1.getName()+" age:"+stu1.getAge()+"address"+stu1.getAddress().getAdd());
System.out.println("stu2:"+stu2.getName()+" age:"+stu2.getAge()+"address"+stu2.getAddress().getAdd());
}
}
stu1:张三 age:18address北京
stu2:李四 age:20address上海
如果引用类型里面还包含很多引用类型，或者内层引用类型的类里面又包含引用类型，使用clone方法就会很麻烦。这时我们可以用序列化的方式来实现对象的深克隆。
public class Student implements Serializable {
private static final long serialVersionUID = -3950409490183038226L;
private String name;
private int age;
private Address address;
public Student CloneObject(Object obj){
Student student = null;
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(obj);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
student = (Student) ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return student;
}
......
public class Address implements Serializable {
private static final long serialVersionUID = -4265312082191071263L;
private String add;
@Override
protected Address clone() throws CloneNotSupportedException {
return (Address)super.clone();
}
.....
}
public class Test {
public static void main(String[] args){
Student stu1 = new Student("张三",18,new Address("上海"));
Student stu2 = stu1.CloneObject(stu1);
stu2.setName("李四");
stu2.setAge(20);
stu1.setAddress(new Address("北京"));
System.out.println("stu1:"+stu1.getName()+" age:"+stu1.getAge()+"address"+stu1.getAddress().getAdd());
System.out.println("stu2:"+stu2.getName()+" age:"+stu2.getAge()+"address"+stu2.getAddress().getAdd());
}
}
stu1:张三 age:18address北京
stu2:李四 age:20address上海
总结：
实现对象克隆有两种方式：
1). 实现Cloneable接口并重写Object类中的clone()方法；
2). 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆.
注意：
基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用Object类的clone方法克隆对象。让问题在编译的时候暴露出来总是优于把问题留到运行时。