Object.clone()深浅拷贝

一、核心概念与机制

1. clone()方法的基本行为

protected native Object clone() throws CloneNotSupportedException;

• 浅拷贝：默认实现，仅复制对象本身及其基本类型字段
• 深拷贝：需要手动实现，复制对象及其引用的所有对象

2. 内存模型对比

浅拷贝内存模型

graph LR
A[原对象] -->|引用| B[内部对象]
C[克隆对象] -->|同一引用| B[内部对象]

深拷贝内存模型

graph LR
A[原对象] -->|引用| B[内部对象]
C[克隆对象] -->|新引用| D[新内部对象]

二、实现克隆的规范步骤

1. 类必须实现Cloneable接口

public class MyClass implements Cloneable {
    // 类实现
}

2. 重写clone()方法并提升访问权限

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

3. 实现深拷贝的完整模式

public class DeepCopyExample implements Cloneable {
    private int id;
    private List<String> data;
    private CustomObject ref;
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        DeepCopyExample cloned = (DeepCopyExample) super.clone();
        // 手动创建新的列表对象
        cloned.data = new ArrayList<>(this.data);
        // 克隆引用对象
        cloned.ref = (CustomObject) this.ref.clone();
        return cloned;
    }
}

三、深浅拷贝实现示例

1. 浅拷贝示例

class ShallowCopy implements Cloneable {
    int[] data = {1, 2, 3};
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

// 测试
ShallowCopy original = new ShallowCopy();
ShallowCopy copy = (ShallowCopy) original.clone();
original.data[0] = 100;  // 修改原对象
System.out.println(copy.data[0]); // 输出100（共享同一数组）

2. 深拷贝示例

class DeepCopy implements Cloneable {
    int[] data = {1, 2, 3};
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        DeepCopy copy = (DeepCopy) super.clone();
        copy.data = data.clone();  // 克隆数组
        return copy;
    }
}

// 测试
DeepCopy original = new DeepCopy();
DeepCopy copy = (DeepCopy) original.clone();
original.data[0] = 100;  // 修改原对象
System.out.println(copy.data[0]); // 输出1（独立数组）

四、复杂对象的深拷贝实现

1. 多层级对象克隆

class Department implements Cloneable {
    String name;
    Employee manager;
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        Department copy = (Department) super.clone();
        copy.manager = (Employee) manager.clone();  // 克隆员工对象
        return copy;
    }
}

class Employee implements Cloneable {
    String name;
    Address address;
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        Employee copy = (Employee) super.clone();
        copy.address = (Address) address.clone();  // 克隆地址对象
        return copy;
    }
}

class Address implements Cloneable {
    String city;
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();  // 简单对象可直接调用super.clone()
    }
}

2. 集合类型的深拷贝

class Company implements Cloneable {
    List<Department> departments = new ArrayList<>();
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        Company copy = (Company) super.clone();
        // 创建新的ArrayList
        copy.departments = new ArrayList<>(departments.size());
        // 深拷贝每个部门
        for (Department dept : departments) {
            copy.departments.add((Department) dept.clone());
        }
        return copy;
    }
}

五、常见错误与解决方案

六、替代clone()的方案

1. 复制构造函数

public class Employee {
    private String name;
    private Address address;
    
    // 复制构造函数
    public Employee(Employee other) {
        this.name = other.name;
        this.address = new Address(other.address);  // 深拷贝
    }
}

2. 工厂方法

public class Product {
    private Configuration config;
    
    public static Product newInstance(Product prototype) {
        Product copy = new Product();
        copy.config = prototype.config.deepCopy();
        return copy;
    }
}

3. 序列化实现深拷贝

public static <T extends Serializable> T deepCopy(T object) {
    try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
         ObjectOutputStream oos = new ObjectOutputStream(baos)) {
        oos.writeObject(object);
        
        try (ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
             ObjectInputStream ois = new ObjectInputStream(bais)) {
            return (T) ois.readObject();
        }
    } catch (IOException | ClassNotFoundException e) {
        throw new RuntimeException("Deep copy failed", e);
    }
}

七、最佳实践与性能优化

1. 不可变对象策略

   public final class ImmutablePoint {
       private final int x;
       private final int y;
   
       public ImmutablePoint(int x, int y) {
           this.x = x;
           this.y = y;
       }
   
       // 无需clone方法，直接返回自身
       public ImmutablePoint copy() {
           return this;
       }
   }
   

2. 对象池技术

   public class ObjectPool {
       private static final Map<Prototype, Prototype> pool = new HashMap<>();
   
       public static Prototype getInstance(Prototype proto) {
           return pool.computeIfAbsent(proto, k -> {
               try {
                   return (Prototype) k.clone();
               } catch (CloneNotSupportedException e) {
                   throw new RuntimeException(e);
               }
           });
       }
   }
   

3. 克隆性能优化

   • 对于大型对象，使用增量复制
   • 缓存常用克隆对象
   • 使用System.arraycopy()优化数组复制

八、克隆与并发安全

class ThreadSafeContainer implements Cloneable {
    private final Map<String, Object> data = new ConcurrentHashMap<>();
    
    @Override
    public Object clone() {
        try {
            ThreadSafeContainer copy = (ThreadSafeContainer) super.clone();
            // 创建新的ConcurrentHashMap
            copy.data = new ConcurrentHashMap<>(this.data);
            return copy;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(); // 不可能发生
        }
    }
}

九、总结：选择拷贝策略的决策树

graph TD
    A[需要复制对象？] -->|是| B{对象包含引用类型字段？}
    B -->|否| C[使用浅拷贝]
    B -->|是| D{引用对象是否可变？}
    D -->|否| C
    D -->|是| E{引用对象是否支持深拷贝？}
    E -->|是| F[实现深拷贝]
    E -->|否| G[使用替代方案：<br/>1. 复制构造函数<br/>2. 序列化<br/>3. 手动创建]

十、关键要点

1. clone()默认是浅拷贝，仅复制对象本身
2. 深拷贝需要手动实现，递归复制所有引用对象
3. 实现Cloneable接口是必须的，否则抛出异常
4. final字段限制是深拷贝的主要挑战
5. 替代方案（复制构造/序列化）通常更安全可靠
6. 不可变对象是避免拷贝问题的最佳设计

正确实现深拷贝对于维护对象独立性、保证程序正确性至关重要。在复杂系统中，建议优先考虑不可变对象设计或使用序列化方案，避免直接使用clone()方法带来的潜在陷阱。