当我们复制一个对象时，浅拷贝和深拷贝是两种不同的方式，它们在复制对象时处理字段引用的方式不同：
- 浅拷贝（Shallow Copy）：
浅拷贝是一种复制对象的方式，在该方式下，被复制对象的字段值（基本类型）将会被复制到新对象中。
对于字段引用的对象，新对象将引用原始对象中相同的对象。换句话说，新对象和原始对象共享相同的引用对象，而不是创建它们的副本。
这意味着如果修改新对象中的引用对象，原始对象中相应的字段也会受到影响，因为它们引用同一个对象。
浅拷贝通常是通过 clone() 方法来实现的。
- 深拷贝（Deep Copy）：
深拷贝是一种复制对象的方式，在该方式下，被复制对象的字段值将会被复制到新对象中。
对于字段引用的对象，新对象将创建一个相同但独立的副本。换句话说，新对象和原始对象拥有各自独立的引用对象，它们之间没有共享。
这意味着修改新对象中的引用对象不会对原始对象产生任何影响，因为它们引用不同的对象。
深拷贝需要手动实现，通常需要递归地复制对象的所有引用字段。
举例说明：
首先创建对象MyClass，并让对象implements Cloneable接口，并重写了clone方法。
import java.util.List;
public class MyClass implements Cloneable {
private int value;
private List<String> list;
public MyClass(int value, List<String> list) {
this.value = value;
this.list = list;
}
public void setValue(int value) {
this.value = value;
}
public int getValue() {
return value;
}
public List<String> getList() {
return list;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
接着给MyClass的字段赋值，并进行浅拷贝和深拷贝。
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> originalList = new ArrayList<>();
originalList.add("A");
originalList.add("B");
MyClass original = new MyClass(10, originalList);
try {
// 浅拷贝之前原始对象的状态
System.out.println("浅拷贝之前原始对象的状态： " + original.getValue());
System.out.println("浅拷贝之前原始对象的状态： " + original.getList());
System.out.println("========================");
// 浅拷贝
MyClass shallowCopy = (MyClass) original.clone();
shallowCopy.setValue(20);
shallowCopy.getList().add("C");
// 浅拷贝之后原始对象的状态
System.out.println("浅拷贝之后原始对象的状态： " + original.getValue());
System.out.println("浅拷贝之后原始对象的状态： " + original.getList());
// 浅拷贝之后浅拷贝对象的状态
System.out.println("浅拷贝之后浅拷贝对象的状态： " + shallowCopy.getValue());
System.out.println("浅拷贝之后浅拷贝对象的状态： " + shallowCopy.getList());
System.out.println("========================");
// 深拷贝
List<String> deepCopyList = new ArrayList<>(original.getList());
MyClass deepCopy = new MyClass(original.getValue(), deepCopyList);
deepCopy.setValue(30);
deepCopy.getList().add("D");
// 深拷贝之后原始对象的状态
System.out.println("深拷贝之后原始对象的状态： " + original.getValue());
System.out.println("深拷贝之后原始对象的状态： " + original.getList());
// 深拷贝之后深拷贝对象的状态
System.out.println("深拷贝之后深拷贝对象的状态： " + deepCopy.getValue());
System.out.println("深拷贝之后深拷贝对象的状态： " + deepCopy.getList());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
浅拷贝之前原始对象的状态： 10
浅拷贝之前原始对象的状态： [A, B]
========================
浅拷贝之后原始对象的状态： 10
浅拷贝之后原始对象的状态： [A, B, C]
浅拷贝之后浅拷贝对象的状态： 20
浅拷贝之后浅拷贝对象的状态： [A, B, C]
========================
深拷贝之后原始对象的状态： 10
深拷贝之后原始对象的状态： [A, B, C]
深拷贝之后深拷贝对象的状态： 30
深拷贝之后深拷贝对象的状态： [A, B, C, D]
在上述示例中，我们首先创建了一个原始对象 original，其中包含一个整数值和一个字符串列表。然后，我们进行了浅拷贝和深拷贝操作，并修改了拷贝对象的字段值。
结果显示，浅拷贝对象和原始对象共享相同的列表引用，因此它们都受到修改的影响。而深拷贝对象有其自己的独立列表副本，因此修改它不会影响原始对象。
总结来说，浅拷贝只复制引用，而深拷贝复制引用对象本身，使得原始对象和拷贝对象之间完全独立，互不影响。
