如何理解clone对象

缺乏、安全感 2023-07-12 06:22 20阅读 0赞

## 首先明白为什么要用clone？ ##

在实际编程过程中，我们常常要遇到这种情况：有一个对象 A，在某一时刻 A 中已经包含了一些有效值，此时可能会需要一个和 A 完全相同新对象 B，并且此后对 B 任何改动都不会影响到 A 中的值，也就是说，A 与 B 是两个独立的对象，但 B 的初始值是由 A 对象确定的。在 Java 语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现 clone（）方法是其中最简单，也是最高效的手段。

## new一个对象的过程和clone一个对象的过程的区别 ##

new 操作符的本意是分配内存。程序执行到 new 操作符时，首先去看 new 操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象创建完毕，可以把他的引用（地址）发布到外部，在外部就可以使用这个引用操纵这个对象。

clone 在第一步是和 new 相似的，都是分配内存，调用 clone 方法时，分配的内存和原对象（即调用 clone 方法的对象）相同，然后再使用原对象中对应的各个域，填充新对象的域，填充完成之后，clone 方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。

## clone 对象的使用 ##

##### 复制对象和复制引用的区别： #####

1. Person p = new Person(23, "zhang");
    2. Person p1 = p;
    3. System.out.println(p);
    4. System.out.println(p1);

当 Person p1 = p;执行之后， 是创建了一个新的对象吗？ 首先看打印结果：

1．com.itheima.Person@2f9ee1ac
    2．com.itheima.Person@2f9ee1ac

可以看出，打印的地址值是相同的，既然地址都是相同的，那么肯定是同一个对象。p 和 p1 只是引用而已，他们都指向了一个相同的对象 Person(23, “zhang”) 。 可以把这种现象叫做引用的复制。上面代码执行完成之后， 内存中的情景如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTE1MTk2MA_size_16_color_FFFFFF_t_70]

##### 而下面的代码是真真正正的克隆了一个对象。 #####

1．Person p = new Person(23, "zhang");
    2．Person p1 = (Person) p.clone();
    3．System.out.println(p);
    4．System.out.println(p1);

从打印结果可以看出，两个对象的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个新的引用变量：

1. com.itheima.Person@2f9ee1ac
    2. com.itheima.Person@67f1fba0

以上代码执行完成后， 内存中的情景如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTE1MTk2MA_size_16_color_FFFFFF_t_70 1]

#### 深拷贝和浅拷贝 ####

上面的示例代码中，Person 中有两个成员变量，分别是 name 和 age， name 是 String 类型， age 是 int 类型。代码非常简单，如下所示：

1．public class Person implements Cloneable{ 
    2．privatint age ;
    3． private String name;
    4． public Person(int age, String name) { 
    5． this.age = age;
    6． this.name = name;
    7． } 8． public Person() { }
    9． public int getAge() { 
    10． return age;
    11． }
    12． public String getName() { 
    13． return name;
    14． }
    15． @Override
    16． protected Object clone() throws CloneNotSupportedException { 
    17． return (Person)super.clone();
    18． }
    19．}

由于 age 是基本数据类型，那么对它的拷贝没有什么疑议，直接将一个 4 字节的整数值拷贝过来就行。但是 name是 String 类型的， 它只是一个引用， 指向一个真正的 String 对象，那么对它的拷贝有两种方式： 直接将原对象中的 name 的引用值拷贝给新对象的 name 字段， 或者是根据原 Person 对象中的 name 指向的字符串对象创建一个新的相同的字符串对象，将这个新字符串对象的引用赋给新拷贝的 Person 对象的 name 字段。这两种拷贝方式分别叫做浅拷贝和深拷贝。深拷贝和浅拷贝的原理如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTE1MTk2MA_size_16_color_FFFFFF_t_70 2]  
下面通过代码进行验证。如果两个 Person 对象的 name 的地址值相同， 说明两个对象的 name 都指向同一个String 对象，也就是浅拷贝， 而如果两个对象的 name 的地址值不同， 那么就说明指向不同的 String 对象， 也就是在拷贝 Person 对象的时候， 同时拷贝了 name 引用的 String 对象， 也就是深拷贝。验证代码如下：

1. Person p = new Person(23, "zhang");
    2. Person p1 = (Person) p.clone();
    3. String result = p.getName() == p1.getName()
    4. ? "clone 是浅拷贝的" : "clone 是深拷贝的";
    5. System.out.println(result);

打印结果为：

6. clone 是浅拷贝的

所以，clone 方法执行的是浅拷贝， 在编写程序时要注意这个细节。

##### 如何进行深拷贝： #####

由上面的内容可以得出如下结论：如果想要深拷贝一个对象，这个对象必须要实现 Cloneable 接口，实现 clone方法，并且在 clone 方法内部，把该对象引用的其他对象也要 clone 一份，这就要求这个被引用的对象必须也要实现Cloneable 接口并且实现 clone 方法。那么，按照上面的结论，实现以下代码 Body 类组合了 Head 类，要想深拷贝Body 类，必须在 Body 类的 clone 方法中将 Head 类也要拷贝一份。代码如下：

1．static class Body implements Cloneable{ 
    2． public Head head;
    3． public Body() { }
    4． public Body(Head head) { this.head = head;}
    5． @Override
    6． protected Object clone() throws CloneNotSupportedException { 
    7． Body newBody = (Body) super.clone();
    8． newBody.head = (Head) head.clone();
    9． return newBody;
    10． }
    11．}
    12．static class Head implements Cloneable{ 
    13． public Face face;
    14． public Head() { }
    15． @Override
    16． protected Object clone() throws CloneNotSupportedException { 
    17． return super.clone();
    18． } }
    19．public static void main(String[] args) throws CloneNotSupportedException { 
    20． Body body = new Body(new Head(new Face()));
    21． Body body1 = (Body) body.clone();
    22． System.out.println("body == body1 : " + (body == body1) );
    23． System.out.println("body.head == body1.head : " + (body.head == body1.head));
    24．}

打印结果如下：

1. body == body1 : false
    2. body.head == body1.head : false

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTE1MTk2MA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200307170432942.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTE1MTk2MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTE1MTk2MA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020030717055614.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTE1MTk2MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTE1MTk2MA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200307170758285.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTE1MTk2MA==,size_16,color_FFFFFF,t_70