关于Java中Clonable接口和深拷贝详解

// 引用类型：地址（被 User 类引用）
class Address {
    private String city;

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

    // getter/setter
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
}

// 实现 Cloneable 接口，支持浅拷贝
class User implements Cloneable {
    private String name; // 基本类型包装类（不可变，浅拷贝无问题）
    private int age;     // 基本类型（浅拷贝直接复制值）
    private Address addr;// 引用类型（浅拷贝仅复制引用，共享对象）

    // 构造方法
    public User(String name, int age, Address addr) {
        this.name = name;
        this.age = age;
        this.addr = addr;
    }

    // 重写 clone() 方法：实现浅拷贝
    @Override
    public User clone() throws CloneNotSupportedException {
        // 调用 Object 的 clone()，JVM 会创建新对象并复制成员值
        return (User) super.clone();
    }

    // getter/setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public Address getAddr() { return addr; }
}

// 测试浅拷贝
public class ShallowCopyTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        // 1. 创建原对象
        Address addr = new Address("北京");
        User user1 = new User("张三", 20, addr);

        // 2. 浅拷贝得到新对象
        User user2 = user1.clone();

        // 3. 验证：基本类型/不可变类型的拷贝（独立）
        System.out.println(user1.getName() == user2.getName()); // true（String 不可变，共享无问题）
        user2.setName("李四");
        user2.setAge(22);
        System.out.println(user1.getName()); // 张三（原对象不受影响）
        System.out.println(user1.getAge());  // 20（原对象不受影响）

        // 4. 验证：引用类型的拷贝（共享）
        System.out.println(user1.getAddr() == user2.getAddr()); // true（同一个 Address 对象）
        user2.getAddr().setCity("上海"); // 修改 user2 的 Address
        System.out.println(user1.getAddr().getCity()); // 上海（原对象的 Address 也被修改！）
    }
}

// 步骤1：让引用类型 Address 也实现 Cloneable，支持拷贝
class Address implements Cloneable {
    private String city;

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

    // 重写 clone() 方法
    @Override
    public Address clone() throws CloneNotSupportedException {
        return (Address) super.clone();
    }

    // getter/setter 略
}

// 步骤2：User 类的 clone() 中，手动拷贝 Address
class User implements Cloneable {
    private String name;
    private int age;
    private Address addr;

    // 构造方法略

    @Override
    public User clone() throws CloneNotSupportedException {
        // 第一步：浅拷贝 User 对象本身
        User newUser = (User) super.clone();
        // 第二步：手动拷贝引用类型成员（深拷贝核心）
        newUser.addr = this.addr.clone(); // 递归拷贝 Address
        return newUser;
    }

    // getter/setter 略
}

// 测试深拷贝
public class DeepCopyTest1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address addr = new Address("北京");
        User user1 = new User("张三", 20, addr);
        User user2 = user1.clone();

        // 验证：引用类型成员不再共享
        System.out.println(user1.getAddr() == user2.getAddr()); // false（不同 Address 对象）
        user2.getAddr().setCity("上海");
        System.out.println(user1.getAddr().getCity()); // 北京（原对象不受影响）
        System.out.println(user2.getAddr().getCity()); // 上海（新对象独立修改）
    }
}

import java.io.*;

// 步骤1：所有相关类实现 Serializable 接口（标记可序列化）
class Address implements Serializable {
    private String city;
    public Address(String city) { this.city = city; }
    // getter/setter 略
}

class User implements Serializable {
    private String name;
    private int age;
    private Address addr;

    public User(String name, int age, Address addr) {
        this.name = name;
        this.age = age;
        this.addr = addr;
    }

    // 步骤2：实现深拷贝工具方法（序列化+反序列化）
    public User deepCopy() throws IOException, ClassNotFoundException {
        // 1. 序列化：将对象写入字节流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this); // 写入当前 User 对象

        // 2. 反序列化：从字节流读取新对象
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (User) ois.readObject(); // 生成独立的新对象
    }

    // getter/setter 略
}

// 测试序列化深拷贝
public class DeepCopyTest2 {
    public static void main(String[] args) throws Exception {
        Address addr = new Address("北京");
        User user1 = new User("张三", 20, addr);
        User user2 = user1.deepCopy();

        // 验证：完全独立
        System.out.println(user1.getAddr() == user2.getAddr()); // false
        user2.getAddr().setCity("上海");
        System.out.println(user1.getAddr().getCity()); // 北京
        System.out.println(user2.getAddr().getCity()); // 上海
    }
}