Java 深拷贝与浅拷贝

最新推荐文章于 2024-08-04 19:00:00 发布

常戚戚

最新推荐文章于 2024-08-04 19:00:00 发布

阅读量505

点赞数

分类专栏： JAVA学习

本文链接：https://blog.csdn.net/u010293702/article/details/45009447

版权

JAVA学习专栏收录该内容

41 篇文章 1 订阅

订阅专栏

1 Java 中对象的创建

clone顾名思义就是复制，在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。

那么在java语言中，创建对象可以通过：
1，使用new操作符创建一个对象
2，使用clone方法复制一个对象

使用clone而不是new一个类的原因：
clone 方法是native 方法，效率要远高于非native的方法

关于 clone（）方法

clone 是定义在Object 类下的基本方法，定义如下：

protected native Object clone() throws CloneNotSupportedException;

可以看到
1）clone方法是 protected 修饰的native 方法
2）克隆方法返回的是一个Object对象，所以必须要经过强制类型转换。

复制对象 or 复制引用

// ‘=’ 赋值
        Clones c0 = new Clones("abc",123);
        Clones c1 = c0;
        System.out.println(c0);
        System.out.println(c1);

输出：

com.something.Clones@1581593
com.something.Clones@1581593

可以看出打印地址是相同的，则肯定是同一个对象。c0 c1 只是一个引用，他们指向同一个对象。
这里写图片描述

而使用clone 方法时：

    Clones c0 = new Clones("abc",123);
        Clones c1 = (Clones)c0.clone();
        System.out.println(c0);
        System.out.println(c1);

打印结果：

com.something.Clones@1f06dc3
com.something.Clones@1b64e6a

两个对象的地址是不同的，也就是说创建了新的对象，而不是把原对象的地址赋给了一个新的引用变量。

这里写图片描述

在源码的注释中可以看到：

/**
* Creates and returns a copy of this object. The precise meaning
* of “copy” may depend on the class of the object. The general
* intent is that, for any object {@code x}, the expression:
* x.clone() != x
* will be true, and that the expression:
* x.clone().getClass() == x.getClass() 所属类形同
* will be {@code true}, but these are not absolute requirements.
* While it is typically the case that:
* x.clone().equals(x) 对象内容相同
* will be {@code true}, this is not an absolute requirement.

x.clone() != x 必须为真，也就是对于**基础类型**来说，其克隆后在堆中有两个**独立且内容相同的内存区域**。而对于**引用类型**来说，其**引用也不相同。**也就是说克隆对象和原始对象在java 堆(heap)中是两个独立的对象。

2 深拷贝浅拷贝

拷贝是复制一个对象的副本。但是一个对象中有可能有基本数据类型，也有对象数据类型。

shallow clone 浅拷贝：要克隆的对象，对于基本数据类型的属性，复制一个新的，对于非基本类型的属性，仅复制引用给新的对象，而指向同一个对象
deep clone 深拷贝：引用的对象的值也被改变了。深复制把要复制的对象所引用的对象都复制了一遍。

1，浅拷贝：

实现java.lang.Cloneable 接口。
Cloneable 接口是一个标识接口，不包含任何方法。调用Object 类中的clone方法必须要实现Cloneable 接口，否则会抛出异常
重写java.lang.Object.clone()方法。
将clone权限设置为public。 clone方法返回一个Object对象的拷贝。注意：1，返回的是一个新的对象,2，返回的对象与new操作符返回的区别就是这个拷贝已经包含了一些原来对象的信息。

clone 方法产生的效果：先在内存中开辟一块和原始对象一样的空间，然后鸳鸯拷贝原始对象中的内容。

public class Product implements Cloneable {   
    private String name;   

    public Object clone() {   
        try {   
            return super.clone();   
        } catch (CloneNotSupportedException e) {   
            return null;   
        }   
    }   
}

2，深拷贝

即对非基本类型的属性也实现拷贝。

对于要拷贝的类和类中所有的非基本数据类型的属性对应的类：

都实现java.lang.Cloneable接口
都重写java.lang.Object.clone()方法

深拷贝与浅拷贝：
这里写图片描述

深拷贝：

public class CloneTest {

    public static void main(String[] args) throws CloneNotSupportedException{

        Head  head = new Head();
        Body  body = new Body(head);
        Body  newBody = body.clone();
        System.out.println(body.head==newBody.head);
    }

}
class Body implements Cloneable{  
    public Head head;  
    public Body() {}  
    public Body(Head head) {this.head = head;}  


    protected Body clone () throws CloneNotSupportedException{
        Body  newBody = (Body) super.clone();
        //将newBody 中的head也进行克隆
        newBody.head = (Head) head.clone();
        return  newBody;
    }


}  
class Head implements Cloneable{  
    public  int face;  

    public Head() {}  
    public Head(int face){this.face = face;}  

    protected Object clone() throws CloneNotSupportedException {  
        return super.clone();  
    }  
}