java浅拷贝和深拷贝

java语言本身具有对对象的复制功能，Java.lang.Object具有受保护的clone()方法， 使用这个方法的前提是要实现Cloneable接口，调用clone()方法返回的克隆对象是一种“浅克隆”，什么意思呢？就是这种克隆“不彻底”，也就是克隆对象和原对象还有千丝万缕的联系，先拿一个例子证明一下：

package clone;

public class JavaClone {
    public static void main(String[] args) {
        student stu1=new student("zhangsan");
        professor pro1=new professor("professor");
        stu1.setProfessor(pro1);
        student stu2=(student) stu1.clone();
        System.out.println("stu1.getClass()==stu2.getClass() ? "+(stu1.getClass()==stu2.getClass()));
        System.out.println("stu1==stu2 ? "+(stu1==stu2));
        //验证原对象和拷贝对象引用的对其他是否一致
        System.out.println("stu1.getProfessor()==stu2.getProfessor() ? "+(stu1.getProfessor()==stu2.getProfessor()));
    }
}

class student implements Cloneable{
    //定义一个对其他类对象的引用
    private professor professor;
    private String name;
    public student(String name){
        this.setName(name);
    }
    public Object clone(){
        Object copyObject=null;
        try {
            copyObject=super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return copyObject;
    }
    public professor getProfessor() {
        return professor;
    }
    public void setProfessor(professor professor) {
        this.professor = professor;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
class professor {
    private String name;
    public professor(String name){
        this.setName(name);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

运行程序，可得如下结果：

stu1.getClass()==stu2.getClass() ? true
stu1==stu2 ? false
stu1.getProfessor()==stu2.getProfessor() ? true

第一行没得说，原对象和克隆对象的运行时类当然是同一个类了，都是student类，第二行也没得说，原对象和克隆对象不是同一个对象，否则也不叫“克隆”了，而第三行就有些古怪了，原对象对其他对象的引用和克隆对象对其他对象的引用竟然是相同的！而这正是“浅克隆”的特征：原有对象的变量与克隆对象的变量具有相同的值，它们对其他对象的引用都是相同的，也就是克隆对象对其他对象的引用和原对象对其他对象的引用是同一个引用，“浅克隆”并未做到对对象中引用的克隆，所以说，这种克隆不是彻底的。那么，怎样才能做到对对象中的所有内容都克隆一遍呢？这就是深克隆要做的事了， 先看例子：

package clone;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class JavaClone {
    public static void main(String[] args) {
        student stu1=new student("zhangsan");
        professor pro1=new professor("professor");
        stu1.setProfessor(pro1);
        student stu2=(student) stu1.deepclone();
        System.out.println("stu1.getClass()==stu2.getClass() ? "+(stu1.getClass()==stu2.getClass()));
        System.out.println("stu1==stu2 ? "+(stu1==stu2));
        //验证原对象和拷贝对象引用的对其他是否一致
        System.out.println("stu1.getProfessor()==stu2.getProfessor() ? "+(stu1.getProfessor()==stu2.getProfessor()));
    }
}

class student implements Cloneable,Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 827518515795699774L;
    //定义一个对其他类对象的引用
    private professor professor;
    private String name;
    public student(String name){
        this.setName(name);
    }
    public Object deepclone(){
        Object copyObject=null;
        try {
            ByteArrayOutputStream bo=new ByteArrayOutputStream();
            ObjectOutputStream oo=new ObjectOutputStream(bo);
            oo.writeObject(this);
            ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
            ObjectInputStream oi=new ObjectInputStream(bi);
            return oi.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return copyObject;
    }
    public professor getProfessor() {
        return professor;
    }
    public void setProfessor(professor professor) {
        this.professor = professor;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
class professor implements Cloneable,Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 7201762075804205074L;
    private String name;
    public professor(String name){
        this.setName(name);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

运行结果如下：

stu1.getClass()==stu2.getClass() ? true
stu1==stu2 ? false
stu1.getProfessor()==stu2.getProfessor() ? false

这里用到了串行化技术，所谓“串行化”就是将对象写到流里的过程，把对象从流中读出来的称为“并行化”，这里写到流里面的对象是一个拷贝，源对象仍在JVM中，当我们将流里的这份拷贝又写到JVM中，相当于又创建了一个和原来对象内容一样的对象，但是二者是不同的对象，这样就实现了克隆时将对象中不管是引用还是非引用的变量都进行了一遍复制，这就是“深克隆”。

注意一点，在深克隆时，所有的类均要实现java.io.Serializable接口，因为什么？因为我们需要将对象写到流里并再从流里读出对象。总结到此，晚安，睡个好觉...