Java中的克隆（Cloning）介绍及使用示例

本文链接：https://blog.csdn.net/jackiendsc/article/details/144815110

一、克隆的介绍及示例

在Java中，克隆（Cloning）指的是创建一个对象的副本，使得原始对象和克隆对象在内存中拥有相同的属性值，但是是两个不同的对象实例。Java提供了两种克隆方式：浅克隆（Shallow Clone）和深克隆（Deep Clone）。

浅克隆

浅克隆只复制对象本身和对象中的基本数据类型字段，而不复制对象中的引用类型字段指向的对象。换句话说，浅克隆后的对象与原始对象共享引用类型字段所引用的对象。

要实现浅克隆，需要让类实现Cloneable接口，并重写Object类中的clone()方法。Cloneable接口是一个标记接口，它本身不包含任何方法，但它告诉JVM该类支持克隆。

以下是一个浅克隆的示例：

class Person implements Cloneable {
    String name;
    Address address; // 引用类型字段

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

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

    @Override
    public String toString() {
        return "Person{name='" + name + "', address=" + address + '}';
    }
}

class Address {
    String city;

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

    @Override
    public String toString() {
        return "Address{city='" + city + "'}";
    }
}

public class ShallowCloneDemo {
    public static void main(String[] args) {
        try {
            Address address = new Address("Beijing");
            Person person1 = new Person("Alice", address);
            Person person2 = (Person) person1.clone();

            System.out.println(person1);
            System.out.println(person2);

            // 修改person2的address字段的city属性
            person2.address.city = "Shanghai";

            System.out.println("After modifying person2's address:");
            System.out.println(person1);
            System.out.println(person2);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

运行上述代码，你会看到修改person2的address字段的city属性后，person1的address字段的city属性也被修改了，这是因为它们共享同一个Address对象。

深克隆

深克隆不仅复制对象本身，还复制对象中的所有引用类型字段指向的对象。换句话说，深克隆后的对象与原始对象完全独立，没有任何共享的对象。

要实现深克隆，通常需要手动复制对象中的所有引用类型字段指向的对象，或者使用序列化/反序列化的方式来实现。

以下是一个使用序列化/反序列化实现深克隆的示例：

import java.io.*;

class Person implements Serializable {
    String name;
    Address address; // 引用类型字段

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

    public Person deepClone() throws IOException, ClassNotFoundException {
        // 序列化对象到字节流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        oos.close();

        // 从字节流反序列化对象
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (Person) ois.readObject();
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', address=" + address + '}';
    }
}

class Address implements Serializable {
    String city;

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

    @Override
    public String toString() {
        return "Address{city='" + city + "'}";
    }
}

public class DeepCloneDemo {
    public static void main(String[] args) {
        try {
            Address address = new Address("Beijing");
            Person person1 = new Person("Alice", address);
            Person person2 = person1.deepClone();

            System.out.println(person1);
            System.out.println(person2);

            // 修改person2的address字段的city属性
            person2.address.city = "Shanghai";

            System.out.println("After modifying person2's address:");
            System.out.println(person1);
            System.out.println(person2);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

运行上述代码，你会看到修改person2的address字段的city属性后，person1的address字段的city属性并没有被修改，这是因为它们拥有不同的Address对象。