// 引用類型：地址（被 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 會創(chuàng)建新對象并復制成員值
        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. 創(chuàng)建原對象
        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. 序列化：將對象寫入字節(jié)流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this); // 寫入當前 User 對象

        // 2. 反序列化：從字節(jié)流讀取新對象
        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()); // 上海
    }
}