#浅拷贝与深拷贝

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

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

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

    @Override
    protected Person clone() {
        try {
            return (Person) super.clone(); // 默认是浅拷贝
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

Person p1 = new Person("Alice", new Address("Beijing"));
Person p2 = p1.clone();

// 浅拷贝结果：
// p1.name = "Alice", p1.address = Address@123
// p2.name = "Alice", p2.address = Address@123 ← 同一个对象！

// 修改 p2 的引用类型字段会影响 p1：
p2.address.city = "Shanghai";
System.out.println(p1.address.city); // Shanghai ← 被影响了！

class Person implements Cloneable {
    String name;
    Address address;

    @Override
    protected Person clone() {
        try {
            Person cloned = (Person) super.clone();
            // ✅ 深拷贝：手动克隆引用字段
            cloned.address = this.address.clone();
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

// 深拷贝结果：
// p1.address = Address@123
// p2.address = Address@456 ← 新对象！

// 修改 p2 的引用类型字段不影响 p1：
p2.address.city = "Shanghai";
System.out.println(p1.address.city); // Beijing ← 没被影响

// Cloneable 是一个"标记接口"，没有任何方法
// 它的问题是：clone() 方法不是 Cloneable 定义的！

public interface Cloneable { }

// Object.clone() 是这样工作的：
// protected native Object clone() throws CloneNotSupportedException;
// 只有实现了 Cloneable，Object.clone() 才返回字段拷贝
// 否则抛 CloneNotSupportedException

class BadClass { }
BadClass obj = new BadClass();
obj.clone(); // ❌ CloneNotSupportedException（没有实现 Cloneable）

// 坑一：返回 Object，需要强制类型转换
Person p = (Person) super.clone();

// 坑二：必须处理受检异常
try {
    return (Person) super.clone();
} catch (CloneNotSupportedException e) {
    // ...
}

// 坑三：final 字段无法深拷贝
class Person implements Cloneable {
    String name;
    final Address address = new Address(); // final 字段
    @Override
    protected Person clone() {
        Person cloned = (Person) super.clone();
        // ❌ 无法为 final 字段重新赋值
        // cloned.address = this.address.clone(); // 编译错误
        return cloned;
    }
}

// 坑四：引用链深层拷贝
class A {
    B b;
}
class B {
    C c;
}
class C {
    String data;
}
// 深拷贝 A 需要同时克隆 B 和 C，一层层嵌套

class Address implements Cloneable {
    String city;
    @Override
    protected Address clone() { return new Address(this.city); }
}

class Person implements Cloneable {
    String name;
    Address address;
    @Override
    protected Person clone() {
        Person cloned = (Person) super.clone();
        cloned.address = this.address.clone();
        return cloned;
    }
}

// 方式一：JSON 序列化（推荐）
public static <T> T deepCopy(T obj) {
    ObjectMapper mapper = new ObjectMapper();
    return mapper.readValue(mapper.writeValueAsString(obj), (Class<T>) obj.getClass());
}

// 方式二：Java 序列化
public static <T extends Serializable> T deepCopy(T obj) {
    try {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        oos.close();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        @SuppressWarnings("unchecked")
        T copy = (T) ois.readObject();
        return copy;
    } catch (Exception e) {
        throw new IllegalArgumentException("Clone failed", e);
    }
}

// Apache Commons Lang
public static <T> T deepClone(T obj) {
    try {
        byte[] bytes = SerializationUtils.serialize((Serializable) obj);
        return (T) SerializationUtils.deserialize(bytes);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

// Apache Commons BeanUtils
BeanUtils.cloneProperties(target, source); // 浅拷贝
BeanUtils.copyProperties(target, source);  // 浅拷贝
// 深拷贝需要自定义转换器

// Guava 的深拷贝
public static <T> T deepCopy(T obj) {
    return new Gson().fromJson(new Gson().toJson(obj), obj.getClass());
}

// 场景一：DTO 拷贝（字段简单）
UserDTO dto = modelMapper.map(user, UserDTO.class);

// 场景二：复杂对象图
Person deepCopy = new Gson().fromJson(new Gson().toJson(person), Person.class);

// 场景三：需要高性能
// 使用手动 clone() 或 proto-protobuf 等高性能序列化

// 场景四：需要保留对象关系
// 例如：树形结构节点间有父子引用
// 深拷贝时需要手动维护引用关系

// 阿里巴巴 Java 开发规约：不推荐使用 clone()
// 原因：
// 1. clone() 是 Object 的 protected 方法，调用不便
// 2. CloneNotSupportedException 是受检异常
// 3. 字段逐个拷贝，不够灵活
// 4. 无法拷贝 final 字段
// 5. 类型安全问题（强制类型转换）

// ✅ 推荐的替代方案：
// 1. 构造器拷贝
new Person(existing.getName(), existing.getAddress().clone())

// 2. 工厂方法
Person.from(other)

// 3. 序列化工具
SerializationUtils.clone(obj)