Java浅拷贝和深拷贝知识点总结

1. 拷贝

无论是深拷贝还是浅拷贝，他们都需要当前的类支持Cloneable，并且重写了clone方法后才能进行拷贝。

如果只依赖Cloneable，不重写clone方法，则无法调用clone方法（因为他是个protect方法）
如果只重写clone方法，不依赖Cloneable，则会报错。

Exception in thread "main" java.lang.CloneNotSupportedException: copy.B
	at java.lang.Object.clone(Native Method)
	at copy.B.clone(B.java:16)
	at copy.test.main(test.java:6)

至于为什么会报这个错误，在Cloneable的接口注释上已经有说明：

Invoking Object’s clone method on an instance that does not implement the
Cloneable interface results in the exception
CloneNotSupportedException being thrown.

翻译一下就是：如果你调用clone方法的实例所在的类没有implement Cloneable，就会报CloneNotSupportedException

2. 浅拷贝

1. 浅拷贝时，如果遇到基本数据类型和String，会将这个值直接复制一份传入到新类中
2. 浅拷贝时，如果遇到引用数据类型，只会将该数据内存地址的引用复制一份传入到新类中，也就是说新类和原类中持有的对象是同一对象。

举例：

public class A{
    String name;

    A(){
        name = "name";
    }

    @Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                ", hashcode='" + hashCode() + '\''  +
                '}';
    }
}

public class B{
    String id;
    int age;
    A a;

    B(){
        id = "10";
        age = 20;
        a = new A();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "B{" +
                "id=" + id +
                ", age=" + age +
                ", a=" + a +
                '}';
    }
}

测试代码：

public static void main(String[] args) throws CloneNotSupportedException {
    B b1 = new B();
    B b2 = (B)b1.clone();
    System.out.println("b1 = " + b1);
    System.out.println("b2 = " + b2);

    System.out.println("修改b2参数后的b1和b2的值为：");
    b2.id = "15";
    b2.age = 30;
    b2.a.name = "test";
    System.out.println("b1 = " + b1);
    System.out.println("b2 = " + b2);
}

运行结果：

b1 = B{id=10, age=20, a=A{name='name', hashcode='460141958'}}
b2 = B{id=10, age=20, a=A{name='name', hashcode='460141958'}}
修改b2参数后的b1和b2的值为：
b1 = B{id=10, age=20, a=A{name='test', hashcode='460141958'}}
b2 = B{id=15, age=30, a=A{name='test', hashcode='460141958'}}

可以看到，我们只是修改了b2中a.name的值，但是b1中a.name的值也跟着一起修改了，这表明b1和b2持有的a是同一对象（事实上hashCode相同已经证明是同一对象了）。

3. 深拷贝

但是如果我们需要在修改b2的a.name值的同时，不修改b1的a.name。这个时候就需要用到深拷贝

深拷贝实际上就是自定义的拷贝。通过生成一个新的类A来赋值给b2。

举例：

将类A也继承cloneable接口，并且重写clone方法

public class A implements Cloneable{
    String name;

    A(){
        name = "name";
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                ", hashcode='" + hashCode() + '\''  +
                '}';
    }
}

然后重写类B的clone方法

public class B implements Cloneable{

	...... 省略之前出现的代码......
	
    @Override
    protected Object clone() throws CloneNotSupportedException {
        B b2 = (B) super.clone();
        A a2 = (A) a.clone();
        b2.a = a2;
        return b2;
    }
}

再次运行测试代码查看结果，这次很明显b1和b2的a不是同一个对象了。

b1 = B{id=10, age=20, a=A{name='name', hashcode='460141958'}}
b2 = B{id=10, age=20, a=A{name='name', hashcode='1163157884'}}
修改b2参数后的b1和b2的值为：
b1 = B{id=10, age=20, a=A{name='name', hashcode='460141958'}}
b2 = B{id=15, age=30, a=A{name='test', hashcode='1163157884'}}

最后要注意的是，对于某个类中持有的多个引用对象，深拷贝需要将其持有的每个类都实现Clonable和重写clone方法。
如果有多级引用，那每一级也都要实现。

参考材料

Java 浅拷贝和深拷贝 - 简书
https://www.jianshu.com/p/94dbef2de298