java 浅拷贝和深拷贝 示例

在 Java 中，对象的拷贝分为浅拷贝和深拷贝两种。浅拷贝只是拷贝了对象的引用，而不是对象本身；深拷贝则是拷贝了对象本身，包括对象中的所有属性。

下面是一个示例，展示了如何实现浅拷贝和深拷贝：

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

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

class Address {
    private String city;

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

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

在这个示例中，`Person` 类包含一个 `Address` 对象。下面分别展示了浅拷贝和深拷贝的实现方式。

浅拷贝示例：

Person person1 = new Person("Tom", 20, new Address("Beijing"));
Person person2 = (Person) person1.clone();

// 修改 person2 的地址
person2.getAddress().setCity("Shanghai");

// person1 和 person2 的地址都变成了 Shanghai
System.out.println(person1.getAddress().getCity()); // 输出 Shanghai
System.out.println(person2.getAddress().getCity()); // 输出 Shanghai

在上面的示例中，`person2` 是通过 `person1` 进行浅拷贝得到的，因此它们的地址是相同的。当我们修改 `person2` 的地址时，`person1` 的地址也被修改了。

深拷贝示例：

public class DeepCopyDemo {
    public static void main(String[] args) throws Exception {
        Person person1 = new Person("Tom", 20, new Address("Beijing"));
        Person person2 = (Person) deepCopy(person1);

        // 修改 person2 的地址
        person2.getAddress().setCity("Shanghai");

        // person1 的地址没有变化
        System.out.println(person1.getAddress().getCity()); // 输出 Beijing
        System.out.println(person2.getAddress().getCity()); // 输出 Shanghai
    }

    private static Object deepCopy(Object obj) throws Exception {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);

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

在上面的示例中，我们使用了 Java 提供的序列化和反序列化机制来实现深拷贝。通过将对象写入一个 `ByteArrayOutputStream` 中，然后再从一个 `ByteArrayInputStream` 中读取对象，就可以得到一个新的、深拷贝的对象。