深拷贝与浅拷贝理解

前言

在java中，Object类，提供的clone方法就是浅拷贝（对象）。
在java中，如果某个类需要调用Object的clone完成对象的拷贝，必须让该类实现。
在java中，如果一个类要实现clone方法，必须要实现一个接口（Cloneable）。
在java中，存在了一类接口，里面没有任何代码，称为：标注接口！！！允许对象进行拷贝。

浅拷贝

在进行对象拷贝时候，仅仅完成了对象的第一层拷贝，如果该对象存在着子对象，则不会拷贝子对象

下面代码进行解释一下：
首先创建一个User类，实现clone方法进行对象拷贝，然后在测试类里面测试结果，发现名字一样拷贝成功，地址的值已经不一样了。浅拷贝能满足80%的场景，并且浅拷贝的好处就在于浪费内存非常少，不会涉及底层的拷贝。设计到底层的拷贝就要用到深拷贝了。

class User implements Cloneable{
    private String username;
    public User(String username) {this.username = username; }
    public User(){}
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    @Override
    public String toString() { return "User{" + "username='" + username + '\'' + '}'; }
    @Override
    protected Object clone() throws CloneNotSupportedException { return super.clone(); }
}

public class demo01 {
    public static void main(String[] args) throws CloneNotSupportedException {
        User user = new User();
        user.setUsername("linlin");
        User user3 = (User) user.clone();
        System.out.println(user);
        System.out.println(user3);
        System.out.println(user3 == user);
    }
}

代码结果：
User{username=‘linlin’}
User{username=‘linlin’}
false

深拷贝

递归拷贝，会把所有的对象全部分离。
1、让子对象也实现Cloneable接口，在父对象进行拷贝时，子对象也同时拷贝。（第一种比较麻烦）
2、通过序列化对象和反序列化来实现深拷贝。（后续待更新）

深拷贝比较浪费内存，效率非常的差，很少出现分离所有对象。

下面代码进行解释一下：
首先创建一个User类，实现clone方法进行对象拷贝，再创建一个 Dog类，实现clone方法进行对象拷贝，然后在测试类里面测试结果。

class User implements Cloneable{

    private Dog dog;
    private String username;
    public User(Dog dog, String username) { this.dog = dog;this.username = username; }
    public User(){}
    public Dog getDog() { return dog; }
    public void setDog(Dog dog) { this.dog = dog; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    @Override
    public String toString() { return "User{" + "username='" + username + '\'' + '}'; }
    @Override
    protected Object clone() throws CloneNotSupportedException { return super.clone(); }
}

public class Dog implements Cloneable{
    private String name;
    public Dog(String name) { this.name = name; }
    public Dog(){}
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    @Override
    public String toString() { return "Dog{" + "name='" + name + '\'' + '}'; }
    @Override
    protected Object clone() throws CloneNotSupportedException { return super.clone(); }
}

public class demo01 {
    public static void main(String[] args) throws CloneNotSupportedException {
        User user = new User();
        user.setUsername("linlin");
        user.setDog(new Dog("旺财"));
        
        User user3 = (User) user.clone();
        System.out.println(user);
        System.out.println(user3);
        System.out.println(user3 == user);

        user.setUsername("qiuqiu");
        System.out.println(user);
        System.out.println(user3);

        //判断养的狗是否已经完成了拷贝
        System.out.println(user.getDog().getName());
        System.out.println(user3.getDog().getName());
        System.out.println(user.getDog() == user3.getDog());
        user.getDog().setName("大旺");
        System.out.println(user3.getDog().getName());
        System.out.println(user1.getDog().getName());
        System.out.println(user.getDog() == user3.getDog());
    }
}

代码结果如下：
User{username=‘linlin’}
User{username=‘linlin’}
false
User{username=‘qiuqiu’}
User{username=‘linlin’}
旺财
旺财
true
大旺
大旺
true