Java深复制与浅复制

浅复制

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对对象中的基本数据类型及String类型进行拷贝，但不会复制主对象里面的引用对象。
简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

深复制

除了浅复制要复制的值外，还负责复制引用类型的数据。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深度复制把要复制的对象所引用的对象都复制了一遍，而这种对被引用到的对象的复制叫做间接复制。
　深度复制要深入到多少层，是一个不易确定的问题。在决定以深度复制的方式复制一个对象的时候，必须决定对间接复制的对象是采取浅度复制还是继续采用深度复制。因此，在采取深度复制时，需要决定多深才算深。此外，在深度复制的过程中，很可能会出现循环引用的问题，必须小心处理。

实现深复制的两种方式

1. 实现Cloneable接口，重写clone方法：

public class Student implements Cloneable{

    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }
    private String name;
    private String age;
    private Teacher teacher;
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
    @Override
    protected Object clone() {
        Student o = null;
        try {
            o = (Student) super.clone();
            //对引用对象进行clone，要求被引用的对象也要实现Cloneable接口
            o.setTeacher((Teacher) teacher.clone());
        } catch (CloneNotSupportedException e) {
        }
        return o;
    }
}
public class Teacher implements Cloneable {
    private String name;
    public Teacher(String string) {
        this.name = string;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    protected Object clone() {
        Teacher t = null;
        try {
            t = (Teacher) super.clone();
        } catch (CloneNotSupportedException e) {
        }
        return t;
    }
}
测试：
    public static void main(String[] args) {
        Student xiaoming = new Student("xiaoming", "18");
        Teacher teacher = new Teacher("yan");
        xiaoming.setTeacher(teacher);
		
        Student xiaohong = (Student) xiaoming.clone();		
        System.out.println(xiaohong.getTeacher().getName());
        teacher.setName("liu");
        System.out.println("-------------------------");
        System.out.println(xiaohong.getTeacher().getName());
    }

2. 通过序列化方式，实现serializable接口

public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private String age;
    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }
    private Teacher teacher;
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}
public class Teacher implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;

    public Teacher(String string) {
        this.name = string;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

测试：
    public static void main(String[] args) {
        Student xiaoming = new Student("xiaoming", "18");
        Teacher teacher = new Teacher("yan");
        xiaoming.setTeacher(teacher);
        try {           
            //写入流里
            ByteArrayOutputStream bos=new ByteArrayOutputStream();
            ObjectOutputStream oos=new ObjectOutputStream(bos);
            oos.writeObject(xiaoming);
                        
            // 从流里读出来
      ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois=new ObjectInputStream(bis);           
            Student xiaohong =(Student)ois.readObject();

            System.out.println(xiaohong.getTeacher().getName());
            teacher.setName("liu");
            System.out.println("-------------------------");
            System.out.println(xiaohong.getTeacher().getName());
        } catch (IOException e) {

        } catch (ClassNotFoundException e) {         
        }
    }