java浅克隆与深克隆详解

定义

克隆：从已有对象，得到一个新对象

浅克隆与深克隆的区别

1. 浅克隆：两个对象之间，还有共享的内容
2. 深克隆：两个对象之间，完全没有共享的内容

造成这种区别的原因：基本类型和引用类型

clone()方法原理

clone()方法，是一个native方法，也就是虚拟机实现的方法，它会在堆中新开辟一块内存，然后储存已有对象的成员变量信息，成员变量是基本类型则存值，引用类型则存地址

使用Object的clone()方法，需要

1. 实现Clonealbe接口
2. 重写clone()方法，并把protected改为public（扩大访问范围）

其实浅克隆与深克隆，在于自己的实现，一层层实现clone，就是深克隆了

克隆详解（clone）

1. 当对象只存在基本类型或String类型时，就是深克隆，两个对象成员变量的改变不会相互影响

public class Student implements Cloneable {
    private int age;
    private String name;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    // get set constructor toString
}
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1 = new Student(14, "Tom");
        Student s2 = (Student) s1.clone();
        
        // 输出改变前的值
        System.out.println("changed before -----");
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);
        
        // 改变s1的值
        s1.setAge(18);
        s1.setName("Tom1");
        
        // 输出改变后的值
        System.out.println("changed after ------");
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);
    }
}
/*
changed before -----
s1: Student{age=14, name='Tom'}
s2: Student{age=14, name='Tom'}
changed after ------
s1: Student{age=18, name='Tom1'}
s2: Student{age=14, name='Tom'}
*/

可以看到，s1的改变，不会影响到s2的值，也就是说，大家没有共享的内容，就是深克隆

2. 当对象有引用类型时，就是浅克隆，一个对象内容的改变，会影响到另一个对象

public class Student implements Cloneable {
    private int age;
    private String name;
    private Teacher teacher;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    // get set constructor toString
}
public class Teacher {
    private int age;
    private String name;

    // get set constructor toString
}
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher(30, "Jerry");
        Student s1 = new Student(14, "Tom", teacher);
        Student s2 = (Student) s1.clone();

        // 输出改变前的值
        System.out.println("changed before -----");
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);

        // 改变s1的值
        s1.setAge(18);
        s1.setName("Tom1");
        teacher.setAge(33);
        teacher.setName("Jerry1");

        // 输出改变后的值
        System.out.println("changed after ------");
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);
    }
}
/*
changed before -----
s1: Student{age=14, name='Tom', teacher=Teacher{age=30, name='Jerry'}}
s2: Student{age=14, name='Tom', teacher=Teacher{age=30, name='Jerry'}}
changed after ------
s1: Student{age=18, name='Tom1', teacher=Teacher{age=33, name='Jerry1'}}
s2: Student{age=14, name='Tom', teacher=Teacher{age=33, name='Jerry1'}}
*/

1. 基本类型和String类型的值，不会随着s1的改变而改变
2. 引用类型的值，会随着s1中teacher的改变而改变

原因：

1. 基本类型克隆的是值，自然是各自一份，不会相互影响，而引用类型克隆的是地址，也就是两个对象共用一个teacher对象，自然就会相互影响
2. 至于String类型，这个比较特殊，它克隆的也是地址，但是，由于String的不可变性（一个地址对应一个字符串， 不会变），所以当s1.setName("Tom1");时，s1的name就指向了"Tom1"的内存地址，而s2还是指向原来"Tom"的内存地址，所以也不会影响到s2的name变量

这个涉及到字符串常量池的知识，可参考[https://blog.csdn.net/balsamspear/article/details/84336880]

3. 前面说了，浅克隆还是深克隆，在于两个方面
   1. 对象是否含有引用类型
   2. 重写的clone方法，是否层层clone

public class Student implements Cloneable {
    private int age;
    private String name;
    private Teacher teacher;

    // 重写clone方法时，层层clone，一直到所有引用类型里没有引用类型
    @Override
    public Object clone() throws CloneNotSupportedException {
        Teacher teacher = (Teacher) getTeacher().clone();
        Student student = (Student) super.clone();
        student.setTeacher(teacher);
        return student;
    }
}
// 所有引用类型，都需要实现Cloneable接口，并重写clone方法，如果含有引用类型，引用类型也需要clone
public class Teacher implements Cloneable {
    private int age;
    private String name;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher(30, "Jerry");
        Student s1 = new Student(14, "Tom", teacher);
        Student s2 = (Student) s1.clone();

        // 输出改变前的值
        System.out.println("changed before -----");
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);

        // 改变s1的值
        s1.setAge(18);
        s1.setName("Tom1");
        teacher.setAge(33);
        teacher.setName("Jerry1");

        // 输出改变后的值
        System.out.println("changed after ------");
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);
    }
}
/*
changed before -----
s1: Student{age=14, name='Tom', teacher=Teacher{age=30, name='Jerry'}}
s2: Student{age=14, name='Tom', teacher=Teacher{age=30, name='Jerry'}}
changed after ------
s1: Student{age=18, name='Tom1', teacher=Teacher{age=33, name='Jerry1'}}
s2: Student{age=14, name='Tom', teacher=Teacher{age=30, name='Jerry'}}
*/

可以看到，s1所有内容的改变，都不会影响到s2，这就是深克隆

如果多层引用类型嵌套时，深克隆就很麻烦，这时可以使用对象流来得到一个“深克隆”的对象

// 实现Serializable接口，支持序列化
public class Student implements Serializable {
    private int age;
    private String name;
    private Teacher teacher;

    // 通过对象的序列化，实现深克隆
    public Student myClone() throws Exception {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(bout);
        out.writeObject(this);
        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
        ObjectInputStream in = new ObjectInputStream(bin);
        return (Student) in.readObject();
    }
    
    // get set constructor toString()
}
// 引用类型的成员变量，也需要实现Serializable接口，支持序列化
public class Teacher implements Serializable {
    private int age;
    private String name;

    // get set constructor toString()
}
public class Client {

    public static void main(String[] args) throws Exception {
        Teacher teacher = new Teacher(30, "Jerry");
        Student s1 = new Student(14, "Tom", teacher);

        // 通过自定义方法，实现克隆
        Student s2 = s1.myClone();

        // 输出改变前的值
        System.out.println("changed before -----");
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);

        // 改变s1的值
        s1.setAge(18);
        s1.setName("Tom1");
        teacher.setAge(33);
        teacher.setName("Jerry1");

        // 输出改变后的值
        System.out.println("changed after ------");
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);
    }
}
/*
changed before -----
s1: Student{age=14, name='Tom', teacher=Teacher{age=30, name='Jerry'}}
s2: Student{age=14, name='Tom', teacher=Teacher{age=30, name='Jerry'}}
changed after ------
s1: Student{age=18, name='Tom1', teacher=Teacher{age=33, name='Jerry1'}}
s2: Student{age=14, name='Tom', teacher=Teacher{age=30, name='Jerry'}}
*/

可以看到，的确实现了深克隆的效果，也更方便