深拷贝 浅拷贝 之 (成员对象)

结论：

浅拷贝：

基本数据类型，创建新的

引用对象，复制原本的，指向相同的内存

深拷贝：

基本数据类型，创建新的

引用对象：创建新的引用对象

深拷贝 浅拷贝 测试代码

public class DeepAndShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        A a = new A();
        a.a = 10;
        a.b = new B(20);

        // 1. 引用赋值（不是拷贝）
        A refCopy = a;

        // 2. 浅拷贝 创建新的引用
        A shallowCopy = a.clone();

        // 3. 深拷贝（需自定义实现）
        A deepCopy = a.deepClone();

        System.out.println("Original: " + a + ", a=" + a.a + ", b=" + a.b.value);
        System.out.println("Ref Copy: " + refCopy + ", a=" + refCopy.a + ", b=" + refCopy.b.value);
        System.out.println("Shallow Copy: " + shallowCopy + ", a=" + shallowCopy.a + ", b=" + shallowCopy.b.value);
        System.out.println("Deep Copy: " + deepCopy + ", a=" + deepCopy.a + ", b=" + deepCopy.b.value);
//        Original: test.A@1b6d3586, a=10, b=20
//        Ref Copy: test.A@1b6d3586, a=10, b=20
//        Shallow Copy: test.A@4554617c, a=10, b=20    浅拷贝创建新的引用，实际数据的内存地址一样
//        Deep Copy: test.A@74a14482, a=10, b=20
        System.out.println(a.b);
        // 修改原始对象
        a.a = 100;
        a.b.value = 200;

        System.out.println("\nAfter modification:");
        System.out.println("Original: a=" + a.a + ", b=" + a.b.value);
        System.out.println("Ref Copy: a=" + refCopy.a + ", b=" + refCopy.b.value);
        System.out.println("Shallow Copy: a=" + shallowCopy.a + ", b=" + shallowCopy.b.value);
        System.out.println("Deep Copy: a=" + deepCopy.a + ", b=" + deepCopy.b.value);
//        After modification:
//        Original: a=100, b=200
//        Ref Copy: a=100, b=200
//        Shallow Copy: a=10, b=200      浅拷贝的成员对象 是之前的？？？？？
//        Deep Copy: a=10, b=20    创建新对象   新的地址  值不变
        System.out.println(shallowCopy.b);   //test.B@1540e19d
        System.out.println(deepCopy.b);   //test.B@677327b6
        System.out.println(a.b);    //test.B@1540e19d
    }
}

class A implements Cloneable {
    int a;
    B b;

    @Override
    public A clone() throws CloneNotSupportedException {
        return (A) super.clone(); // 浅拷贝
    }

    public A deepClone() throws CloneNotSupportedException {
        A copy = (A) super.clone();
        copy.b = this.b.clone(); // 深拷贝：同时克隆B对象
        return copy;
    }
}

class B implements Cloneable {
    int value;
    B(int value) { this.value = value; }

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

Original: test.A@1b6d3586, a=10, b=20
Ref Copy: test.A@1b6d3586, a=10, b=20
Shallow Copy: test.A@4554617c, a=10, b=20
Deep Copy: test.A@74a14482, a=10, b=20
test.B@1540e19d

After modification:
Original: a=100, b=200
Ref Copy: a=100, b=200
Shallow Copy: a=10, b=200
Deep Copy: a=10, b=20
test.B@1540e19d
test.B@677327b6
test.B@1540e19d

其他

• 成员对象是否被深拷贝，取决于其自身的拷贝实现。

• 若成员是浅拷贝的，即使外层对象深拷贝，该成员仍可能共享数据。

• 完全深拷贝需确保所有嵌套成员均支持深拷贝。

浅拷贝（Shallow Copy）

• 仅复制对象的直接成员值（包括指针的值），不复制指针指向的数据。

• 成员对象的行为：

  • 如果成员是值类型（如 C++ 中的非指针对象、Java 中的基本类型），会直接复制值。

  • 如果成员是引用类型（如指针、Java 中的对象引用），则复制引用，新旧对象共享同一份数据。

  • 深拷贝（Deep Copy）

  • 复制对象的所有直接成员值，并为指针成员分配新内存，拷贝其指向的数据。

  • 成员对象的行为：

    • 如果成员是值类型且自身实现了深拷贝（如 C++ 中的拷贝构造函数），则成员会被完全复制。

    • 如果成员是引用类型，需显式实现深拷贝逻辑（如递归调用其 clone() 方法）

    • 

    • 

deepseek图解内存