啥是对象的浅度克隆和深度克隆？

最新推荐文章于 2021-02-19 02:17:17 发布

m0_49589847

最新推荐文章于 2021-02-19 02:17:17 发布

阅读量93

点赞数

本文链接：https://blog.csdn.net/m0_49589847/article/details/107535380

版权

浅度克隆
JDK提供的克隆是浅度克隆，它只将对象中的基础数据类型的成员变量克隆到新对象中，对象中的引用类型只是克隆了一个引用，克隆后的引用类型还是指向原对象，如下图所示

代码如下：

public class Teacher {
private String name;
private int age;

public Teacher(String name,int age){
    this.name = name;
    this.age = age;
}

public String getName() {
    return name;
}

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

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class User implements Cloneable{
private String name;
private int age;
private Teacher teacher;

public User(String name,int age){
    this.name = name;
    this.age = age;
}

public String getName() {
    return name;
}

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

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

public Teacher getTeacher() {
    return teacher;
}

public void setTeacher(Teacher teacher) {
    this.teacher = teacher;
}

@Override
protected User clone() throws CloneNotSupportedException {
    User user = null;
    try {
        user = (User) super.clone();
    } catch (CloneNotSupportedException e){
        e.printStackTrace();
    }
    return user;
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class TestClone {
public static void main(String[] args) throws CloneNotSupportedException {
User user = new User(“Tom”,13);
user.setTeacher(new Teacher(“Jack”,40));
User userClone = user.clone();

    userClone.getTeacher().setName("Jerry");
    userClone.setName("Tom1");
    userClone.setAge(20);

    System.out.println(user.getName() + "|" + user.getAge() + "|" + user.getTeacher().getName());
    System.out.println(userClone.getName() + "|" + userClone.getAge() + "|" + userClone.getTeacher().getName());
    
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
输出结果：

Tom|13|Jerry
Tom1|20|Jerry
1
2
从输出结果可以看出，克隆对象修改name和age不会影响原对象，但对引用类型Teacher做修改，就会影响原对象

深度克隆
深度克隆就是把整个对象完全克隆一份，包括对象中的引用类型,如图所示

JDK没有提供尝试克隆的方法，只能我们自己来实现，把User类的clone()方法自己实现一下就可以实现简单的尝试克隆了

@Override
protected User clone() throws CloneNotSupportedException {
User user = null;

    try {
        user = (User) super.clone();
        //克隆的时候new一个Teacher对象，就可以实现深度克隆
        Teacher te = new Teacher(this.teacher.getName(),this.teacher.getAge());
        user.setTeacher(te);
    } catch (CloneNotSupportedException e){
        e.printStackTrace();
    }
    return user;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
这样就可以实现User对象的深度克隆了，是不是很简单？

你以为这样就学会了深度克隆，那就真的太天真了，这里我只列举了一个最简单的对象

实际在开发过程中遇到的对象远远比这个要复杂的多，可能包含多层对象的嵌套，如果都自己去实现的话，那就太麻烦了，而且容易出现BUG

一种比较常用的实现方式是利用Java的序列化和反序列化

对象序列化必须实现Serializable接口

public class Teacher implements Serializable {
private String name;
private int age;

public Teacher(String name,int age){
    this.name = name;
    this.age = age;
}

public String getName() {
    return name;
}

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

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Teacher implements Serializable {
private String name;
private int age;

public Teacher(String name,int age){
    this.name = name;
    this.age = age;
}

public String getName() {
    return name;
}

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

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class TestClone {
public static void main(String[] args) throws IOException, ClassNotFoundException {
User user = new User(“Tom”,13);
user.setTeacher(new Teacher(“Jack”,40));

    //序列化对象
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
    objectOutputStream.writeObject(user);

    //反序列化对象
    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
    ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
    User cloneUser = (User) objectInputStream.readObject();

    cloneUser.setName("Tom_clone");
    cloneUser.setAge(20);
    cloneUser.getTeacher().setName("Jack_clone");

    System.out.println(user.getName() + "|" + user.getAge() + "|" + user.getTeacher().getName());
    System.out.println(cloneUser.getName() + "|" + cloneUser.getAge() + "|" + cloneUser.getTeacher().getName());
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
输出结果：