如何实现对象的克隆？

参考回答

在 Java 中，实现对象的克隆通常有以下几种方式：

1. 实现 Cloneable 接口并重写 clone() 方法
   • 通过重写 Object 类的 clone() 方法实现浅拷贝。
   • 必须实现 Cloneable 接口，否则会抛出 CloneNotSupportedException。
2. 通过序列化实现深拷贝
   • 利用 ObjectOutputStream 和 ObjectInputStream 将对象写入流再读出来。
3. 通过构造方法实现拷贝
   • 手动在构造方法中复制对象的属性。
4. 使用第三方库（如 Apache Commons Lang 的 SerializationUtils）
   • 提供了一种方便的深拷贝方式。

详细讲解与拓展

1. Cloneable 接口 + clone() 方法

• Cloneable 的原理：
  • Object 类的 clone() 方法是一个本地方法，用于创建当前对象的副本。
  • 如果对象没有实现 Cloneable 接口，则调用 clone() 会抛出 CloneNotSupportedException。
• 实现浅拷贝：
  • 浅拷贝会复制对象本身及其基本数据类型的字段。
  • 如果对象包含引用类型字段，浅拷贝只复制引用地址，两个对象的引用指向同一个内存位置。

示例代码：

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

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 调用 Object 的 clone 方法
    }

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

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person("Alice", 25);
        Person person2 = (Person) person1.clone(); // 克隆对象

        System.out.println("Original: " + person1);
        System.out.println("Clone: " + person2);
    }
}

输出结果：

Original: Person{name='Alice', age=25}
Clone: Person{name='Alice', age=25}

2. 深拷贝

浅拷贝的缺点是对于引用类型字段，只会复制引用地址，导致两个对象共享同一个子对象。如果需要复制整个对象树，可以使用 深拷贝。

方式 1：手动实现深拷贝

• 如果对象中包含引用类型字段，需要在 clone() 方法中递归调用它们的 clone()。 示例代码：

class Address implements Cloneable {
    private String city;

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

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

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

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;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        cloned.address = (Address) address.clone(); // 深拷贝引用类型字段
        return cloned;
    }

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

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("New York");
        Person person1 = new Person("Alice", 25, address);
        Person person2 = (Person) person1.clone();

        System.out.println("Original: " + person1);
        System.out.println("Clone: " + person2);

        // 修改地址字段
        address.city = "Los Angeles";
        System.out.println("After modifying address:");
        System.out.println("Original: " + person1);
        System.out.println("Clone: " + person2);
    }
}

输出结果：

Original: Person{name='Alice', age=25, address=Address{city='New York'}}
Clone: Person{name='Alice', age=25, address=Address{city='New York'}}
After modifying address:
Original: Person{name='Alice', age=25, address=Address{city='Los Angeles'}}
Clone: Person{name='Alice', age=25, address=Address{city='New York'}}

方式 2：通过序列化实现深拷贝

• 将对象写入输出流再读出，创建一个新对象。
• 缺点是性能较差，所有类必须实现 Serializable 接口。

示例代码：

import java.io.*;

class Person implements Serializable {
    private String name;
    private int age;

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

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

    public static Person deepClone(Person person) {
        try {
            // 写入字节流
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(person);
            oos.close();

            // 从字节流读出对象
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (Person) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 25);
        Person person2 = Person.deepClone(person1);

        System.out.println("Original: " + person1);
        System.out.println("Clone: " + person2);
    }
}

3. 使用构造方法实现拷贝

• 手动在构造方法中复制所有字段。
• 简单但繁琐，不适合复杂对象。

示例代码：

class Person {
    private String name;
    private int age;

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

    public Person(Person other) { // 复制构造方法
        this.name = other.name;
        this.age = other.age;
    }

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

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 25);
        Person person2 = new Person(person1); // 使用复制构造方法

        System.out.println("Original: " + person1);
        System.out.println("Clone: " + person2);
    }
}

总结

克隆方式对比

选择克隆方式时，可以根据项目需求和对象复杂程度选择合适的实现方式。例如：

• 简单对象：直接使用 Cloneable 和 clone() 方法。
• 复杂对象：使用序列化或第三方库进行深拷贝。

shuaidi永久会员

收藏 海报挣佣金 推广链接