Java中对象的复制
假如说你想复制一个简单变量。很简单:
1 int n = 5; 2 int m = n;
不仅仅是int类型，其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。但是如果你复制的是一个对象，情况就有些复杂了。
假设说我是一个beginner，我会这样写：
1 class Student {
2 private int number;
3
4 public int getNumber() {
5 return number;
6 }
7
8 public void setNumber(int number) {
9 this.number = number;
10 }
11
12 }
13 public class Test {
14
15 public static void main(String args[]) {
16
17 Student stu1 = new Student();
18 stu1.setNumber(12345);
19 Student stu2 = stu1;
20
21 System.out.println("学生1:" + stu1.getNumber());
22 System.out.println("学生2:" + stu2.getNumber());
23 }
24 }打印结果：
- 学生1:12345
- 学生2:12345
这里我们自定义了一个学生类，该类只有一个number字段。
我们新建了一个学生实例，然后将该值赋值给stu2实例。(Student stu2 = stu1;)
再看看打印结果，作为一个新手，拍了拍胸腹，对象复制不过如此，
难道真的是这样吗？
我们试着改变stu2实例的number字段，再打印结果看看：
1 stu2.setNumber(54321);
2
3 System.out.println("学生1:" + stu1.getNumber());
4 System.out.println("学生2:" + stu2.getNumber());打印结果:
- 学生1:54321
- 学生2:54321
这就怪了，为什么改变学生2的学号，学生1的学号也发生了变化呢？
原因出在(stu2 = stu1) 这一句。该语句的作用是将stu1的引用赋值给stu2，
这样，stu1和stu2指向内存堆中同一个对象。如图：
那么，怎样才能达到复制一个对象呢？
是否记得万类之王Object。它有11个方法，有两个protected的方法，其中一个为clone方法。
该方法的签名是：
protected native Object clone() throws CloneNotSupportedException;
因为每个类直接或间接的父类都是Object，因此它们都含有clone()方法，但是因为该方法是protected，所以都不能在类外进行访问。
要想对一个对象进行复制，就需要对clone方法覆盖。
一般步骤是（浅复制）：
1. 被复制的类需要实现Clonenable接口（不实现的话在调用clone方法会抛出CloneNotSupportedException异常) 该接口为标记接口(不含任何方法)
2. 覆盖clone()方法，访问修饰符设为public。方法中调用super.clone()方法得到需要的复制对象，（native为本地方法)
下面对上面那个方法进行改造：
1 class Student implements Cloneable{
2 private int number;
3
4 public int getNumber() {
5 return number;
6 }
7
8 public void setNumber(int number) {
9 this.number = number;
10 }
11
12 @Override
13 public Object clone() {
14 Student stu = null;
15 try{
16 stu = (Student)super.clone();
17 }catch(CloneNotSupportedException e) {
18 e.printStackTrace();
19 }
20 return stu;
21 }
22 }
23 public class Test {
24
25 public static void main(String args[]) {
26
27 Student stu1 = new Student();
28 stu1.setNumber(12345);
29 Student stu2 = (Student)stu1.clone();
30
31 System.out.println("学生1:" + stu1.getNumber());
32 System.out.println("学生2:" + stu2.getNumber());
33
34 stu2.setNumber(54321);
35
36 System.out.println("学生1:" + stu1.getNumber());
37 System.out.println("学生2:" + stu2.getNumber());
38 }
39 }- 学生1:12345
- 学生2:12345
- 学生1:12345
- 学生2:54321
如果你还不相信这两个对象不是同一个对象，那么你可以看看这一句：
System.out.println(stu1 == stu2); // false
上面的复制被称为浅复制(Shallow Copy)，还有一种稍微复杂的深度复制(deep copy)：
我们在学生类里再加一个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实例的地址。
1 addr.setAdd("西湖区");
2
3 System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
4 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:
1 /**
2 * Return a copy of this object.
3 */
4 public Object clone() {
5 Date d = null;
6 try {
7 d = (Date)super.clone();
8 if (cdate != null) {
9 d.cdate = (BaseCalendar.Date) cdate.clone();
10 }
11 } catch (CloneNotSupportedException e) {} // Won't happen
12 return d;
13 }该类其实也属于深度复制。
转载于:https://www.cnblogs.com/zhouxuanyu/p/4541207.html
Java中对象的复制相关推荐
- Java中对象的深复制（深克隆）和浅复制（浅克隆）介绍
1．浅复制与深复制概念 ⑴浅复制(浅克隆) 被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象.换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象. ⑵ ...
- 浅析Java中对象的创建与对象的数据类型转换
这篇文章主要介绍了Java中对象的创建与对象的数据类型转换,是Java入门学习中的基础知识,需要的朋友可以参考下 Java:对象创建和初始化过程 1．Java中的数据类型 Java中有3个数据 ...
- Java中对象和引用的理解
2019独角兽企业重金招聘Python工程师标准>>> 偶然想起Java中对象和引用的基本概念,为了加深下对此的理解和认识,特地整理一下相关的知识点,通过具体实例从两者的概念和区别两 ...
- java中的的一些生命周期,Java中对象的生命周期
Java中对象的生命周期 (1) 对象生命周期的开始 对象生命周期开始时,需要为对象分配内存,并且初始化它的实例变量: 对象生命周期结束 Java虚拟机的垃圾回收线程回收对象的内存. (2) 创建一个 ...
- [转载] java中对象作为参数传递给一个方法，到底是值传递，还是引用传递
参考链接: 用Java传递和返回对象 看完绝对清晰~ java中对象作为参数传递给一个方法,到底是值传递,还是引用传递? pdd:所谓java只有按值传递:基本类型 值传递:引用类型,地址值传递,所 ...
- Java 中对象占用内存大小计算
原文地址 mp.weixin.qq.com byte 与 bit bit:位,比特.信息的最小单位,二进制数中的一个位数 (二进制位),其值为"0" 或"1": ...
- java 复制 粘贴_在java中如何实现复制，粘贴，剪切
在java中如何实现复制,粘贴,剪切 关注:272 答案:2 mip版 解决时间 2021-01-25 02:48 提问者挥映在沉默里的渲染 2021-01-24 22:41 请分别写出来,而且讲 ...
- Java中对象的储存区
文章目录 1 两个重要的问题 2 C语言中数据的存储区 3 Java中对象的储存区 4 Java为什么采用动态内存分配? 4 为什么基本类型是特例? 1 两个重要的问题 对象的数据位于何处? 如何控制 ...
- Java中对象的实例化顺序
文章目录 1 Java中对象的实例化顺序 1 Java中对象的实例化顺序 继承后的初始化顺序: 静态成员包括静态构造代码块,初始化顺序跟书写顺序有关.
最新文章
- SAP MM已经转成PO的采购申请Item依旧可以被删除？
- 01Python基础_09异常
- http协议、模块、express框架以及路由器、中间件和mysql模块
- 生产环境子域降级记录
- gifcam使用缩小内存_Fedora 上的桌面环境内存占用测试 | Linux 中国
- DELPHI GetClassName - 获取指定窗口的类名
- redis最基础的入门教程
- 今天起高考能查分了！这种方式超方便的
- Coinbase在苹果应用商店前100免费应用中排名第30位
- Spring Date JPA实现增删改查
- POJ NOI0105-43 质因数分解
- Delphi调用外部程序详解
- unity3d 鼠标点击事件处理 处理鼠标点击
- puzzle（1321）时间旅人
- 利用Nodemcu+Arduino nano+TB6612+点灯科技APP制作简易麦克纳姆轮Wi-Fi遥控小车
- 我们要做一个靠谱的人~以信而立天下
- android仿支付宝弹窗,AlipayPassDialog Android 仿支付宝密码键盘弹框，可以自定义样式 Dialog，调节字体颜色大小内容 @codeKK Android开源站...
- 2.阿里实人认证 .net 准备工作2 转换demo
- [Python/转载]Python 100 Day : 初识Python
- 排查定时任务为什么不执行