问：介绍一下Java中的深克隆浅克隆？

在Java中，对象克隆主要有两种方式：浅克隆（Shallow Clone）和深克隆（Deep Clone）。

浅克隆（Shallow Clone）

浅克隆会创建一个新对象，这个新对象有着原始对象属性值的一份精确拷贝。如果属性是基本数据类型，拷贝的就是值本身；如果属性是引用类型，拷贝的是内存地址，因此如果原始对象改变了这些引用类型的属性，克隆对象也会受到影响。

实现浅克隆的步骤：

1. 实现Cloneable接口。
2. 重写Object类的clone()方法。

示例代码：

import java.io.Serializable;

class Address implements Serializable {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    // Getter 和 Setter 省略
}

class Person implements Cloneable {
    private String name;
    private Address address;

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

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

    // Getter 和 Setter 省略
}

public class ShallowCloneExample {
    public static void main(String[] args) {
        try {
            Address addr = new Address("Beijing");
            Person original = new Person("Alice", addr);

            Person cloned = (Person) original.clone();

            System.out.println("Original Person: " + original.name + ", Address: " + original.address.city);
            System.out.println("Cloned Person: " + cloned.name + ", Address: " + cloned.address.city);

            // 修改原始对象的地址
            original.address.city = "Shanghai";

            // 验证克隆对象的地址是否也被修改
            System.out.println("After modification, Original Address: " + original.address.city);
            System.out.println("After modification, Cloned Address: " + cloned.address.city);

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

注意事项：

• 浅克隆只复制对象本身和包含的所有值类型的成员变量，而引用类型的成员变量仍然指向原来的对象。
• 如果需要深克隆，则需要自定义克隆逻辑，确保所有引用类型的成员变量也被克隆。

深克隆（Deep Clone）

深克隆不仅复制对象本身，还复制对象所引用的所有对象，并创建新的内存地址。这样，原始对象和克隆对象之间就完全独立了。

实现深克隆的常用方法：

• 使用序列化（Serialization）和反序列化（Deserialization）。

示例代码（使用序列化实现深克隆）：

import java.io.*;

// 假设Person和Address类如上定义，并实现了Serializable接口

public class DeepCloneExample {
    public static void main(String[] args) {
        try {
            Address addr = new Address("Beijing");
            Person original = new Person("Alice", addr);

            Person cloned = deepClone(original);

            System.out.println("Original Person: " + original.name + ", Address: " + original.address.city);
            System.out.println("Cloned Person: " + cloned.name + ", Address: " + cloned.address.city);

            // 修改原始对象的地址
            original.address.city = "Shanghai";

            // 验证克隆对象的地址是否也被修改
            System.out.println("After modification, Original Address: " + original.address.city);
            System.out.println("After modification, Cloned Address: " + cloned.address.city);

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static <T> T deepClone(T object) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(object);

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);

        @SuppressWarnings("unchecked")
        T clonedObj = (T) ois.readObject();
        return clonedObj;
    }
}

注意事项：

• 序列化方式虽然可以实现深克隆，但会涉及到IO操作，可能会影响性能

对比总结

下面是关于深克隆和浅克隆差异的对比总结两者之间的主要区别：

通过这个对比，可以清晰地看到深克隆和浅克隆在定义、复制范围、内存分配、对象独立性、实现方式、复杂性和性能等方面的主要差异。这些差异使得它们适用于不同的场景和需求。