如何在 Java 中通过 super.clone() 确保在实现深拷贝时能够正确触发父类及 Object 的克隆链-java教程-PHP中文网

super.clone()不会自动触发克隆链，它仅调用直接父类的clone()方法；深拷贝需每层显式处理自身引用字段，通过super.clone()协作完成自底向上克隆。

如何在 java 中通过 super.clone() 确保在实现深拷贝时能够正确触发父类及 object 的克隆链

在 Java 中，super.clone() 本身不会自动“触发克隆链”，它只是调用直接父类的 clone() 方法 —— 而这个方法是否执行深拷贝、是否继续向上委托，完全取决于父类的实现。要确保深拷贝正确贯穿整个继承链（包括 Object），关键不在于“触发链”，而在于**每一层都显式、正确地参与深拷贝逻辑**。

1. 理解 clone() 的默认行为与继承约束

Object.clone() 是浅拷贝，且是 protected 的。子类若想支持克隆，必须：

实现 Cloneable 接口（否则抛 CloneNotSupportedException）；
重写 public Object clone()，并在其中调用 super.clone()；
对所有需要深拷贝的引用字段，手动重新创建副本并赋值。

注意：super.clone() 不会自动递归调用祖父类的 clone() —— 它只调用直接父类重写的版本（如果父类没重写，则最终落到 Object.clone()）。因此，“链”不是自动的，而是靠每层主动协作构建的。

2. 每一层都必须显式处理自己的可变引用字段

假设类继承链为 A → B → C（C 最派生），且三者都有需深拷贝的引用字段：

A.clone()：调用 super.clone()（即 Object.clone()），再手动深拷贝 A 自己的字段；
B.clone()：调用 super.clone()（即 A.clone()），再手动深拷贝 B 自己新增的字段；
C.clone()：调用 super.clone()（即 B.clone()），再手动深拷贝 C 自己新增的字段。

这样，每次 clone() 都先让父类完成其职责（含父类字段的深拷贝），再处理自身字段 —— 形成自底向上的协作链条。缺失任一环（如某层忘记深拷贝自己的字段），就会导致该层字段仍为浅拷贝。

JavaStoryDevelop

你接手一个需求时，是不是经常这样："改一个小字段 → 结果把不相关的代码也改了"、"需求说得很模糊 → 做着做着发现跑偏了"、"数据库加个字段 → 上线才发现漏了数据兼容"、"做了个新功能 → 一个月后自己都忘了当时怎么设计的"、"写到一半被中断 → 再回来不知道从哪继续"；这个 Skill 就是专门解决这些问题的。它会自动探测你的项目环境（JDK、Spring Boot、ORM、数据库、前端框架），记在

下载

3. 正确使用 super.clone() 的典型模式

以一个三层结构为例：

class A implements Cloneable {
    protected List<string> data = new ArrayList();
    @Override
    public A clone() {
        try {
            A cloned = (A) super.clone(); // 浅拷贝本层字段（data 引用被复制）
            cloned.data = new ArrayList(this.data); // 深拷贝 data
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);
        }
    }
}

class B extends A {
    protected Map<integer string> meta = new HashMap();
    @Override
    public B clone() {
        try {
            B cloned = (B) super.clone(); // 先完成 A 的 clone（含 data 深拷贝）
            cloned.meta = new HashMap(this.meta); // 深拷贝 meta
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);
        }
    }
}

class C extends B {
    protected Date timestamp = new Date();
    @Override
    public C clone() {
        try {
            C cloned = (C) super.clone(); // 先完成 B 的 clone（含 data + meta 深拷贝）
            cloned.timestamp = new Date(this.timestamp.getTime()); // 深拷贝 timestamp
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);
        }
    }
}</integer></string>

这里每层都依赖 super.clone() 完成父类部分的克隆，并在此基础上补充自己字段的深拷贝逻辑 —— 这才是“链”的实质。