对象克隆学习

news2024/11/19 13:30:22

假如说你想复制一个简单变量。很简单：

int apples = 5;  
int pears = apples;

不仅仅是int类型，其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。

但是如果你复制的是一个对象，情况就有些复杂了。

假设说我是一个beginner，我会这样写：

复制代码

class Student {  
    private int number;  
  
    public int getNumber() {  
        return number;  
    }  
  
    public void setNumber(int number) {  
        this.number = number;  
    }  
      
}  
public class Test {  
      
    public static void main(String args[]) {  
        Student stu1 = new Student();  
        stu1.setNumber(12345);  
        Student stu2 = stu1;  
          
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
    }  
}

复制代码

结果：

学生1:12345  

学生2:12345  

这里我们自定义了一个学生类，该类只有一个number字段。

我们新建了一个学生实例，然后将该值赋值给stu2实例。(Student stu2 = stu1;)

再看看打印结果，作为一个新手，拍了拍胸腹，对象复制不过如此，

难道真的是这样吗？

我们试着改变stu2实例的number字段，再打印结果看看：

stu2.setNumber(54321);  
  
System.out.println("学生1:" + stu1.getNumber());  
System.out.println("学生2:" + stu2.getNumber());

结果：

学生1:54321  

学生2:54321  

这就怪了，为什么改变学生2的学号，学生1的学号也发生了变化呢？

原因出在(stu2 = stu1) 这一句。该语句的作用是将stu1的引用赋值给stu2，

这样，stu1和stu2指向内存堆中同一个对象。如图：

那么，怎样才能达到复制一个对象呢？

是否记得万类之王Object。它有11个方法，有两个protected的方法，其中一个为clone方法。

在Java中所有的类都是缺省的继承自Java语言包中的Object类的，查看它的源码，你可以把你的JDK目录下的src.zip复制到其他地方然后解压，里面就是所有的源码。发现里面有一个访问限定符为protected的方法clone()：

复制代码

/*
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 x, the expression:
1) x.clone() != x will be true
2) x.clone().getClass() == x.getClass() will be true, but these are not absolute requirements.
3) x.clone().equals(x) will be true, this is not an absolute requirement.
*/
protected native Object clone() throws CloneNotSupportedException;

复制代码

仔细一看，它还是一个native方法，大家都知道native方法是非Java语言实现的代码，供Java程序调用的，因为Java程序是运行在JVM虚拟机上面的，要想访问到比较底层的与操作系统相关的就没办法了，只能由靠近操作系统的语言来实现。

  1. 第一次声明保证克隆对象将有单独的内存地址分配。
  2. 第二次声明表明，原始和克隆的对象应该具有相同的类类型，但它不是强制性的。
  3. 第三声明表明，原始和克隆的对象应该是平等的equals()方法使用，但它不是强制性的。

因为每个类直接或间接的父类都是Object，因此它们都含有clone()方法，但是因为该方法是protected，所以都不能在类外进行访问。

要想对一个对象进行复制，就需要对clone方法覆盖。

回到顶部

为什么要克隆？

　　大家先思考一个问题，为什么需要克隆对象？直接new一个对象不行吗？

　　答案是：克隆的对象可能包含一些已经修改过的属性，而new出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。那么我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛？可以是可以，但是一来麻烦不说，二来，大家通过上面的源码都发现了clone是一个native方法，就是快啊，在底层实现的。

　　提个醒，我们常见的Object a=new Object();Object b;b=a;这种形式的代码复制的是引用，即对象在内存中的地址，a和b对象仍然指向了同一个对象。

　　而通过clone方法赋值的对象跟原来的对象时同时独立存在的。

回到顶部

如何实现克隆

先介绍一下两种不同的克隆方法，浅克隆(ShallowClone)和深克隆(DeepClone)。

在Java语言中，数据类型分为值类型（基本数据类型）和引用类型，值类型包括int、double、byte、boolean、char等简单数据类型，引用类型包括类、接口、数组等复杂类型。浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制，下面将对两者进行详细介绍。

一般步骤是（浅克隆）：

1. 被复制的类需要实现Clonenable接口（不实现的话在调用clone方法会抛出CloneNotSupportedException异常)， 该接口为标记接口(不含任何方法)

2. 覆盖clone()方法，访问修饰符设为public。方法中调用super.clone()方法得到需要的复制对象。（native为本地方法)

下面对上面那个方法进行改造：

复制代码

class Student implements Cloneable{  
    private int number;  
  
    public int getNumber() {  
        return number;  
    }  
  
    public void setNumber(int number) {  
        this.number = number;  
    }  
      
    @Override  
    public Object clone() {  
        Student stu = null;  
        try{  
            stu = (Student)super.clone();  
        }catch(CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        return stu;  
    }  
}  
public class Test {  
    public static void main(String args[]) {  
        Student stu1 = new Student();  
        stu1.setNumber(12345);  
        Student stu2 = (Student)stu1.clone();  
          
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
          
        stu2.setNumber(54321);  
      
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
    }  
}

复制代码

结果：

学生1:12345  

学生2:12345  

学生1:12345  

学生2:54321

如果你还不相信这两个对象不是同一个对象，那么你可以看看这一句：

System.out.println(stu1 == stu2); // false

上面的复制被称为浅克隆。

还有一种稍微复杂的深度复制：

我们在学生类里再加一个Address类。

复制代码

 1 class Address  {  
 2     private String add;  
 3   
 4     public String getAdd() {  
 5         return add;  
 6     }  
 7   
 8     public void setAdd(String add) {  
 9         this.add = add;  
10     }  
11       
12 }  
13   
14 class Student implements Cloneable{  
15     private int number;  
16   
17     private Address addr;  
18       
19     public Address getAddr() {  
20         return addr;  
21     }  
22   
23     public void setAddr(Address addr) {  
24         this.addr = addr;  
25     }  
26   
27     public int getNumber() {  
28         return number;  
29     }  
30   
31     public void setNumber(int number) {  
32         this.number = number;  
33     }  
34       
35     @Override  
36     public Object clone() {  
37         Student stu = null;  
38         try{  
39             stu = (Student)super.clone();  
40         }catch(CloneNotSupportedException e) {  
41             e.printStackTrace();  
42         }  
43         return stu;  
44     }  
45 }  
46 public class Test {  
47       
48     public static void main(String args[]) {  
49           
50         Address addr = new Address();  
51         addr.setAdd("杭州市");  
52         Student stu1 = new Student();  
53         stu1.setNumber(123);  
54         stu1.setAddr(addr);  
55           
56         Student stu2 = (Student)stu1.clone();  
57           
58         System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
59         System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
60     }  
61 }

复制代码

结果：

学生1:123,地址:杭州市  

学生2:123,地址:杭州市  

乍一看没什么问题，真的是这样吗？

我们在main方法中试着改变addr实例的地址。

addr.setAdd("西湖区");  
  
System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());

结果：

学生1:123,地址:杭州市  
学生2:123,地址:杭州市  
学生1:123,地址:西湖区  
学生2:123,地址:西湖区

这就奇怪了，怎么两个学生的地址都改变了？

原因是浅复制只是复制了addr变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。

所以，为了达到真正的复制对象，而不是纯粹引用复制。我们需要将Address类可复制化，并且修改clone方法，完整代码如下：

复制代码

 1 package abc;  
 2   
 3 class Address implements Cloneable {  
 4     private String add;  
 5   
 6     public String getAdd() {  
 7         return add;  
 8     }  
 9   
10     public void setAdd(String add) {  
11         this.add = add;  
12     }  
13       
14     @Override  
15     public Object clone() {  
16         Address addr = null;  
17         try{  
18             addr = (Address)super.clone();  
19         }catch(CloneNotSupportedException e) {  
20             e.printStackTrace();  
21         }  
22         return addr;  
23     }  
24 }  
25   
26 class Student implements Cloneable{  
27     private int number;  
28   
29     private Address addr;  
30       
31     public Address getAddr() {  
32         return addr;  
33     }  
34   
35     public void setAddr(Address addr) {  
36         this.addr = addr;  
37     }  
38   
39     public int getNumber() {  
40         return number;  
41     }  
42   
43     public void setNumber(int number) {  
44         this.number = number;  
45     }  
46       
47     @Override  
48     public Object clone() {  
49         Student stu = null;  
50         try{  
51             stu = (Student)super.clone();   //浅复制  
52         }catch(CloneNotSupportedException e) {  
53             e.printStackTrace();  
54         }  
55         stu.addr = (Address)addr.clone();   //深度复制  
56         return stu;  
57     }  
58 }  
59 public class Test {  
60       
61     public static void main(String args[]) {  
62           
63         Address addr = new Address();  
64         addr.setAdd("杭州市");  
65         Student stu1 = new Student();  
66         stu1.setNumber(123);  
67         stu1.setAddr(addr);  
68           
69         Student stu2 = (Student)stu1.clone();  
70           
71         System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
72         System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
73           
74         addr.setAdd("西湖区");  
75           
76         System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
77         System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
78     }  
79 }

复制代码

结果：

学生1:123,地址:杭州市  
学生2:123,地址:杭州市  
学生1:123,地址:西湖区  
学生2:123,地址:杭州市

这样结果就符合我们的想法了。

最后我们可以看看API里其中一个实现了clone方法的类：

java.util.Date:

复制代码

/** 
 * Return a copy of this object. 
 */  
public Object clone() {  
    Date d = null;  
    try {  
        d = (Date)super.clone();  
        if (cdate != null) {  
            d.cdate = (BaseCalendar.Date) cdate.clone();  
        }  
    } catch (CloneNotSupportedException e) {} // Won't happen  
    return d;  
}

复制代码

该类其实也属于深度复制。

参考文档：Java如何复制对象

回到顶部

浅克隆和深克隆

1、浅克隆

在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。

简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。

在Java语言中，通过覆盖Object类的clone()方法可以实现浅克隆。

2、深克隆

在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。

简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将复制。

在Java语言中，如果需要实现深克隆，可以通过覆盖Object类的clone()方法实现，也可以通过序列化(Serialization)等方式来实现。

（如果引用类型里面还包含很多引用类型，或者内层引用类型的类里面又包含引用类型，使用clone方法就会很麻烦。这时我们可以用序列化的方式来实现对象的深克隆。）

序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现Serializable接口，否则无法实现序列化操作。

扩展
Java语言提供的Cloneable接口和Serializable接口的代码非常简单，它们都是空接口，这种空接口也称为标识接口，标识接口中没有任何方法的定义，其作用是告诉JRE这些接口的实现类是否具有某个功能，如是否支持克隆、是否支持序列化等。

回到顶部

解决多层克隆问题

如果引用类型里面还包含很多引用类型，或者内层引用类型的类里面又包含引用类型，使用clone方法就会很麻烦。这时我们可以用序列化的方式来实现对象的深克隆。

复制代码

 1 public class Outer implements Serializable{
 2   private static final long serialVersionUID = 369285298572941L;  //最好是显式声明ID
 3   public Inner inner;
 4 　//Discription:[深度复制方法,需要对象及对象所有的对象属性都实现序列化]　
 5   public Outer myclone() {
 6       Outer outer = null;
 7       try { // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
 8           ByteArrayOutputStream baos = new ByteArrayOutputStream();
 9           ObjectOutputStream oos = new ObjectOutputStream(baos);
10           oos.writeObject(this);
11 　　　　　　// 将流序列化成对象
12           ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
13           ObjectInputStream ois = new ObjectInputStream(bais);
14           outer = (Outer) ois.readObject();
15       } catch (IOException e) {
16           e.printStackTrace();
17       } catch (ClassNotFoundException e) {
18           e.printStackTrace();
19       }
20       return outer;
21   }
22 }

复制代码

Inner也必须实现Serializable，否则无法序列化：

复制代码

 1 public class Inner implements Serializable{
 2   private static final long serialVersionUID = 872390113109L; //最好是显式声明ID
 3   public String name = "";
 4 
 5   public Inner(String name) {
 6       this.name = name;
 7   }
 8 
 9   @Override
10   public String toString() {
11       return "Inner的name值为：" + name;
12   }
13 }

复制代码

这样也能使两个对象在内存空间内完全独立存在，互不影响对方的值。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1358691.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

美洽获评2023年度“最佳数字化服务商”，产品优势赋能企业智能转型

美洽获评2023年度“最佳数字化服务商”，产品优势赋能企业智能转型

日前，由知名学习交流平台人人都是产品经理举办的“2023年度评选”活动圆满落幕，美洽凭借在企业服务领域的技术实力与优秀实践成果脱颖而出，入围年度产品评选榜单，获评2023年度“最佳数字化服务商”。 人人都是产品经理成立于2010年…
阅读更多...
邮件营销发件人名称设置指南：提升邮件信誉度与点击率的技巧

邮件营销发件人名称设置指南：提升邮件信誉度与点击率的技巧

正如品牌名称之于产品，发件人名称之于电子邮件。它有助于提高识别度、熟悉度和清晰度。一封邮件的发件人名称可以是话题的开端，也可以是邮件内容的破坏者。 关于电子邮件的发件人名称，你可能经常不得不思考两件事。 我应该用什么名字&#…
阅读更多...
怎么分解一张二维码图片？二维码解码在线处理技巧

怎么分解一张二维码图片？二维码解码在线处理技巧

相信对于制作二维码很多小伙伴还知道怎么操作，那么分解二维码图片的方法有知道的吗？二维码解码也是在日常生活中经常会需要使用的一个功能，当我们需要将一张图片上的二维码分解使用时，那么最方便快捷的方法就是使用二维码解码器工…
阅读更多...
【S32K 进阶之旅】 NXP S32K3 以太网 RMII 接口调试（1）

【S32K 进阶之旅】 NXP S32K3 以太网 RMII 接口调试（1）

前言 大联大世平集团推出了一款基于 NXP 车规级 MCU S32K344 的开发板——花名“Cavalry”，它使用 BGA257 封装的 32 位 ArmCortex-M7 S32K344 作为主控芯片，在69.6*130mm 的小体积开发板上搭载了 SBC 电源管理芯片、CAN 收发器、LIN 收发器、FLASH 存储…
阅读更多...
Rhinoceros 8.2(犀牛8.2)安装教程

Rhinoceros 8.2(犀牛8.2)安装教程

Rhinoceros 8.2下载链接：https://docs.qq.com/doc/DUmhMYmNyUGl6ZVpU 1.选中下载的压缩包，右键解压到“Rhinoceros 8.2”文件夹 2.选中“rhino_en-us_8.2.23346.13001.exe”右键以管理员身份运行 3.点击“小齿轮“ 4.选择安装路径，取消勾选“…
阅读更多...
计算机视觉与美颜SDK：详解人脸美型功能的实现过程

计算机视觉与美颜SDK：详解人脸美型功能的实现过程

众所周知。人脸美型功能作为美颜技术的一项关键特性，对于用户塑造理想形象具有重要意义。本文将深入探讨计算机视觉与美颜SDK中人脸美型功能的实现过程。 一、关键点定位 关键点定位是人脸美型的关键步骤之一。深度学习方法在关键点定位方面取得了巨大的成功&…
阅读更多...
已知输入图像大小为n、卷积核大小为f、卷积步长s，填充大小为p，求解输出图像大小。

已知输入图像大小为n、卷积核大小为f、卷积步长s，填充大小为p，求解输出图像大小。

问题描述：已知输入图像大小为n、卷积核大小为f、卷积步长s，填充大小为p，求解输出图像大小。 问题解答： 输出图像的大小可以使用以下的计算公式确定： 为了举例说明，假设有以下参数： 输入图像大…
阅读更多...
【前端】[vue3] vue-router使用

【前端】[vue3] vue-router使用

提示：我这边用的是typeScript语法，所以js文件的后缀都是ts。 安装vue-router： （注意：vue2引用vue-router3 vue3才引用vue-router4） npm install vue-router4src文件夹下面创建 router/index.ts（…
阅读更多...
如何在CentOS7部署宝塔面板并通过内网穿透实现远程登录面板

如何在CentOS7部署宝塔面板并通过内网穿透实现远程登录面板

文章目录 一、使用官网一键安装命令安装宝塔二、简单配置宝塔，内网穿透三、使用固定公网地址访问宝塔 宝塔面板作为建站运维工具，适合新手，简单好用。当我们在家里/公司搭建了宝塔，没有公网IP，但是想要在外也可以访问内…
阅读更多...
园区网典型组网架构

园区网典型组网架构

知识改变命运，技术就是要分享，有问题随时联系，免费答疑，欢迎联系！ 当您在校园学习，单位工作，商场购物时，您可能会注意到，这些场所都被网络覆盖。通过网络，您可…
阅读更多...
pip install skopt安装显示没有对应版本问题及解决

pip install skopt安装显示没有对应版本问题及解决

一、问题描述以及分析 （一）问题描述 ModuleNotFoundError: No module named skopt pip install skopt Note: you may need to restart the kernel to use updated packages.ERROR: Could not find a version that satisfies the requirement skopt (fro…
阅读更多...
数据分析求职-岗位介绍

数据分析求职-岗位介绍

这是咱们干货开始的第一篇文章，后续我尽量会保持日更的节奏和大家做分享~ 在未来所有分享的内容展开之前，咱们有必要先彻底、深入地了解下数据分析这个岗位。如果你还在犹豫是否要走数据分析的路，或者你已经拿了数据分析的offer想了解下将来…
阅读更多...
SSM建材商城网站----计算机毕业设计

SSM建材商城网站----计算机毕业设计

项目介绍 本项目分为前后台，前台为普通用户登录，后台为管理员登录； 管理员角色包含以下功能： 管理员登录,管理员管理,注册用户管理,新闻公告管理,建材类型管理,配货点管理,建材商品管理,建材订单管理,建材评价管理等功能。 用…
阅读更多...
如何保证幂等性

如何保证幂等性

什么是幂等性？ 调用方对系统进行重复的调用，不管调用多少次，调用对系统的影响都是相同的。系统默认认为外部系统调用失败是常态，失败之后会有重试。 什么情况下会导致幂等性问题？ 网络波动，可能引起重复…
阅读更多...
揭开高速应用最佳光耦合器选择的秘密

揭开高速应用最佳光耦合器选择的秘密

在快节奏的电子领域，光耦合器的重要性再怎么强调都不为过。这些关键组件在确保电子电路不同部分之间的无缝通信方面发挥着关键作用。本文深入探讨了光耦合器的主要参数，并指导您选择理想的高速光耦合器。 了解光耦合器的基础知识 光耦合器通常称为光隔…
阅读更多...
龙芯loongarch64服务器编译安装clang

龙芯loongarch64服务器编译安装clang

前言 Clang 是一款开源的 C、C++、Objective-C 和 Objective-C++ 编程语言的编译器前端。它是 LLVM 编译器基础设施项目的一部分，具有优秀的性能、可扩展性和模块化设计。 Clang 提供了一系列主要功能，包括但不限于： 作为编译器前端，负责将源代码转换为中间表示形式（IR）…
阅读更多...
leetcode：136只出现一次的数字（详解），又名找到单身狗

leetcode：136只出现一次的数字（详解），又名找到单身狗

期末考试临近，每天复习一点知识，还是可以复习完的，加油 前言 我后来才知道这是力扣上的一道题，我当时写他的时候名字叫找到单身狗，即使那个只出现了一次的数字 题目 136. 只出现一次的数字 给你一个 非空 整数数组…
阅读更多...
ChatGPT到底可以做什么？

ChatGPT到底可以做什么？

1、熟练掌握ChatGPT提示词技巧及各种应用方法，并成为工作中的助手。 2、通过案例掌握ChatGPT撰写、修改论文及工作报告，提供写作能力及优化工作 3、熟练掌握ChatGPT融合相关插件的应用，完成数据分析、编程以及深度学习等相关科研项目。 4、…
阅读更多...
AI论文指南|ChatGPT助力论文论据搜集！【建议收藏】

AI论文指南|ChatGPT助力论文论据搜集！【建议收藏】

点击下方▼▼▼▼链接直达AIPaperPass ！ AIPaperPass - AI论文写作指导平台 公众号原文▼▼▼▼： AI论文指南|ChatGPT助力论文论据搜集！【建议收藏】 上一篇文章，小编为宝子们分享了ChatGPT在论文论点提炼方面的内容以及操作流…
阅读更多...
大创项目推荐 深度学习卷积神经网络的花卉识别

大创项目推荐 深度学习卷积神经网络的花卉识别

文章目录 0 前言1 项目背景2 花卉识别的基本原理3 算法实现3.1 预处理3.2 特征提取和选择3.3 分类器设计和决策3.4 卷积神经网络基本原理 4 算法实现4.1 花卉图像数据4.2 模块组成 5 项目执行结果6 最后 0 前言 🔥 优质竞赛项目系列，今天要分享的是 基…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023