Java 深拷贝、浅拷贝及Cloneable接口

转载

mob604756f9eb4d 2017-08-21 09:36:00

文章标签 引用类型浅克隆浅复制数据类型深度复制 文章分类 代码人生

　　原本写过，后来在阅读的时候，感觉自己都不是太明白了，删除后参考人家的又重新写了一份。

一：开篇

1.复制一个变量

　　举例是int类型。

　　其他其中七种原始数据类型同样适用。

　　原始类型：boolean,char,byte,short,float,double.long

1 int apples = 5;  
2 int pears = apples;

2.复制一个对象

 1 package com.jun.it;
 2 
 3 public class CopyTest {
 4 
 5     public static void main(String[] args) {
 6         Student student1=new Student();
 7         student1.setNumber(123);
 8         //复制
 9         Student student2=student1;
10         System.out.println("学生1："+student1.getNumber());
11         System.out.println("学生2："+student2.getNumber());
12 
13     }
14 
15 }
16 
17 class Student{
18     private int number;
19 
20     public int getNumber() {
21         return number;
22     }
23 
24     public void setNumber(int number) {
25         this.number = number;
26     }
27     
28 }

3.效果

　　 Java 深拷贝、浅拷贝及Cloneable接口_引用类型

4.接着说明

　　上面是一个简单的对象复制，但是这种复制有没有问题，下面添加一行程序：student2.setNumber(456);

　　效果就变了，效果如下：

　　 Java 深拷贝、浅拷贝及Cloneable接口_浅克隆_02

　　完整的程序：

 1 package com.jun.it;
 2 
 3 public class CopyTest {
 4 
 5     public static void main(String[] args) {
 6         Student student1=new Student();
 7         student1.setNumber(123);
 8         //复制
 9         Student student2=student1;
10         student2.setNumber(456);
11         System.out.println("学生1："+student1.getNumber());
12         System.out.println("学生2："+student2.getNumber());
13 
14     }
15 
16 }
17 
18 class Student{
19     private int number;
20 
21     public int getNumber() {
22         return number;
23     }
24 
25     public void setNumber(int number) {
26         this.number = number;
27     }
28     
29 }

5.结论

　　在修改2的时候，1也随着改变了。

　　因为在内存堆中是同一个对象。

　　这样的复制是有问题的，所以，具体怎么样才能算一个复制对象呢？

　　在下面会具体的说明。

二：复制原理的说明

1.Object

　　在Object中，有11个方法，有两个projected的方法，其中一个为clone。

　　并且clone是一个native方法，说明这是一个供java调用的程序。

　　每个类都直接或者间接的父类都是Object，都有clone方法，但是都是projected的，所以不能进行类外进行访问。

　　所以，要对对象的复制，就需要对clone方法进行覆盖。

三：为什么要克隆

1.说明

　　在引入克隆的示例之后，需要说明为什么要克隆，直接new对象不好么

2.克隆

　　克隆的对象可能包含一些已经修改过的属性，而new出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。

　　通过上面的源码都发现了clone是一个native方法，就是快啊，在底层实现的。

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

四：如何克隆

1.克隆的两种方式

　　分为浅克隆，和深克隆。

　　数据类型主要分为值类型和引用类型。

　　浅克隆与深克隆主要的区别在于是否支持引用类型的成员变量的复制。

五：浅克隆

1.步骤

　　被复制的类需要实现Clonenable接口

　　　　如果不实现，直接调用clone方法，会抛出CloneNotSupportedException异常

　　覆盖clone方法，访问修饰符设置为public。

　　　　在调用super.clone()可以得到需要的复制对象。

2.程序示例

　　对刚刚的对象程序，做一个修改。

 1 package com.jun.it;
 2 
 3 public class CopyTest2 {
 4 
 5     public static void main(String[] args) {
 6         Student2 student1=new Student2();
 7         student1.setNumber(123);
 8         //复制
 9         Student2 student2=(Student2)student1.clone();
10         
11         System.out.println("学生1："+student1.getNumber());
12         System.out.println("学生2："+student2.getNumber());
13         
14         student2.setNumber(456);
15         System.out.println("学生1："+student1.getNumber());
16         System.out.println("学生2："+student2.getNumber());
17 
18     }
19 
20 }
21 
22 class Student2 implements Cloneable{
23     private int number;
24 
25     public int getNumber() {
26         return number;
27     }
28 
29     public void setNumber(int number) {
30         this.number = number;
31     }
32     
33     //clone
34     public Object clone() {
35         Student2 stu=null;
36         try {
37             stu=(Student2)super.clone();
38         }catch (Exception e) {
39             e.printStackTrace();
40         }
41         return stu;
42     }
43     
44 }

3.效果

　　这样的复制，已经不再是同一个对象了。

　　 Java 深拷贝、浅拷贝及Cloneable接口_浅复制_03

六：深度复制

1.对象中有引用一个引用类型的时候

　　这个深度复制，是源于上面的浅复制。

　　现在，在Student类中加入一个Adress类。

2.程序

　　在修改后的程序，观察是否可以做到合适的复制呢？

 1 package com.jun.it;
 2 
 3 public class CopyTest3 {
 4 
 5     public static void main(String[] args) {
 6         Address address=new Address();
 7         address.setAddress("北京");
 8         Student3 student1=new Student3();
 9         student1.setAddress(address);
10         //复制
11         Student3 student2=(Student3)student1.clone();
12         
13         System.out.println("学生1："+student1.getAddress().getAddress());
14         System.out.println("学生2："+student2.getAddress().getAddress());
15         
16         address.setAddress("上海");18         System.out.println("学生1："+student1.getAddress().getAddress());
19         System.out.println("学生2："+student2.getAddress().getAddress());
20 
21     }
22 
23 }
24 
25 /**
26  * Address
27  * @author dell
28  *
29  */
30 class Address{
31     private String address;
32 
33     public String getAddress() {
34         return address;
35     }
36 
37     public void setAddress(String address) {
38         this.address = address;
39     }
40     
41 }
42 /**
43  * Student
44  * @author dell
45  *
46  */
47 
48 class Student3 implements Cloneable{
49     private int number;
50     private Address address;
51 
52     public int getNumber() {
53         return number;
54     }
55 
56     public void setNumber(int number) {
57         this.number = number;
58     }
59         
60     public Address getAddress() {
61         return address;
62     }
63 
64     public void setAddress(Address address) {
65         this.address = address;
66     }
67 
68     //clone
69     public Object clone() {
70         Student3 stu=null;
71         try {
72             stu=(Student3)super.clone();
73         }catch (Exception e) {
74             e.printStackTrace();
75         }
76         return stu;
77     }
78     
79 }

3.效果

　　在修改地址后，发现不是合适的复制。

　　 Java 深拷贝、浅拷贝及Cloneable接口_数据类型_04

4.结论

　　原因在浅复制，只是复制了address变量的引用，没有正真的开辟一个新的空间，将复制后再把引用返回给新的对象。

　　所以，需要正真的复制对象，而不是纯粹的引用复制。

　　可以让Address类可以被复制化，并且修改clone方法。

5.最新的程序

 1 package com.jun.it;
 2 
 3 public class CopyTest3 {
 4 
 5     public static void main(String[] args) {
 6         Address address=new Address();
 7         address.setAddress("北京");
 8         Student3 student1=new Student3();
 9         student1.setAddress(address);
10         //复制
11         Student3 student2=(Student3)student1.clone();
12         
13         System.out.println("学生1："+student1.getAddress().getAddress());
14         System.out.println("学生2："+student2.getAddress().getAddress());
15         
16         address.setAddress("上海");
17         System.out.println("学生1："+student1.getAddress().getAddress());
18         System.out.println("学生2："+student2.getAddress().getAddress());
19 
20     }
21 
22 }
23 
24 /**
25  * Address
26  * @author dell
27  *
28  */
29 class Address implements Cloneable{
30     private String address;
31 
32     public String getAddress() {
33         return address;
34     }
35 
36     public void setAddress(String address) {
37         this.address = address;
38     }
39     //clone
40     public Object clone() {
41         Address address=null;
42         try {
43             address=(Address)super.clone();
44         }catch (Exception e) {
45             e.printStackTrace();
46         }
47         return address;
48     }
49     
50 }
51 /**
52  * Student
53  * @author dell
54  *
55  */
56 
57 class Student3 implements Cloneable{
58     private int number;
59     private Address address;
60 
61     public int getNumber() {
62         return number;
63     }
64 
65     public void setNumber(int number) {
66         this.number = number;
67     }
68         
69     public Address getAddress() {
70         return address;
71     }
72 
73     public void setAddress(Address address) {
74         this.address = address;
75     }
76 
77     //clone
78     public Object clone() {
79         Student3 stu=null;
80         try {
81             //浅复制
82             stu=(Student3)super.clone();
83         }catch (Exception e) {
84             e.printStackTrace();
85         }
86         //深复制
87         stu.address=(Address)address.clone();
88         return stu;
89     }
90     
91 }