假如这个世界上只剩下你一个人，当你正坐在屋子里的时候，这时突然响起了敲门声...

JAVA 对象拷贝

上一篇 / 下一篇 2008-05-01 18:12:57

查看( 67 ) / 评论( 3 )

JAVA 对象拷贝

为什么需要有对象拷贝？

对象拷贝相对的自然是引用拷贝。java初学者经常会问，我这个方法要改变一个对象的属性，可以把参数传进去了，为什么没有改变了？

——基本数据类型传值，而对象传引用或引用的拷贝。

而有时候我们要获取到一个当前状态的对象复制品，他们是两个独立对象。不再是引用或者引用拷贝（实质都是指向对象本身）。就是说a是b的拷贝，b发生变化的时候，不要影响a。

对象拷贝有浅拷贝和深度拷贝两种。

1）浅拷贝

浅拷贝是指对象中基本数据类型得到拷贝，而引用数据类型并未拷贝。
提到拷贝自然和clone联系起来了，所有具有clone功能的类都有一个特性，那就是它直接或间接地实现了Cloneable接口。
否则，我们在尝试调用clone（）方法时，将会触发CloneNotSupportedException异常。
eg:
1 public class  DOG  implements  Cloneable
2 {
3    public  DOG(String name,  int  age)
4    {
5       this .name  =  name;
6       this .age  =  age;
7    }
8
9    public  String getName()
10    {
11       return this .name;
12    }
13
14    public int  getAge()
15    {
16       return this .age;
17    }
18
19    public  Object clone()
20    {
21       try
22       {
23             return super .clone();
24
25       } catch  (CloneNotSupportedException e)
26       {
27             return null ;
28       }
29    }
30
31    public  String name;
32
33    private int  age;
34
35    // test
36    public static void  main(String[] args)
37    {
38       DOG dog1  = new  DOG( " xiaogou " ,  2 );
39       DOG dog2  =  (DOG) dog1.clone();
40       dog1.name  = " dagou " ;
41       System.out.println(dog2.getName());
42       System.out.println(dog2.getAge());
43       System.out.println(dog1.getName());
44       System.out.println(dog1.getAge());
45
46    }
47
48 }
49

运行结果：

xiaogou
2
dagou
2

2）深度拷贝

相对浅拷贝。实现对象中基本数据类型和引用数据类型的拷贝。

请先看下面代码：

1 class  AAA
2 {
3    public  AAA(String name)
4    {
5       this .name  =  name;
6    }
7
8    public  String name;
9 }
10
11 class  DOG  implements  Cloneable
12 {
13    public  DOG(String name,  int  age, AAA birthday)
14    {
15       this .name  =  name;
16       this .age  =  age;
17       this .birthday  =  birthday;
18    }
19
20    public  String getName()
21    {
22       return  name;
23    }
24
25    public int  getAge()
26    {
27       return  age;
28    }
29
30    public  AAA getBirthday()
31    {
32       return  birthday;
33    }
34
35    public  String getBirth(AAA a)
36    {
37       return  a.name;
38    }
39
40    public  String name;
41
42    private int  age;
43
44    public  AAA birthday;
45
46    public  Object clone()
47    {
48       try
49       {
50             super .clone();
51             return super .clone();
52       } catch  (Exception e)
53       {
54             return null ;
55       }
56    }
57 }
58
59 public class  TestClone
60 {
61    public static void  main(String[] args)
62    {
63       AAA Day  = new  AAA( " test " );
64       DOG dog1  = new  DOG( " xiaogou " ,  2 , Day);
65       DOG dog2  =  (DOG) dog1.clone();
66       // dog2.birthday = (AAA) dog1.birthday.clone();
67       dog1.birthday.name  = " 333 " ;
68       System.out.println(dog1.getBirth(dog1.birthday));
69       System.out.println(dog2.getBirth(dog2.birthday));
70    }
71 }
72

运行结果是：
333
333
而真正要实现拷贝还的加点代码，如下请对比上面和下面代码的异同之处：

1 class  AAA  implements  Cloneable
2 {
3    public  AAA(String name)
4    {
5       this .name  =  name;
6    }
7
8    public  Object clone()
9    {
10       try
11       {
12             super .clone();
13             return super .clone();
14       } catch  (Exception e)
15       {
16             return null ;
17       }
18    }
19
20    public  String name;
21 }
22
23 class  DOG  implements  Cloneable
24 {
25    public  DOG(String name,  int  age, AAA birthday)
26    {
27       this .name  =  name;
28       this .age  =  age;
29       this .birthday  =  birthday;
30    }
31
32    public  String getName()
33    {
34       return  name;
35    }
36
37    public int  getAge()
38    {
39       return  age;
40    }
41
42    public  AAA getBirthday()
43    {
44       return  birthday;
45    }
46
47    public  String getBirth(AAA a)
48    {
49       return  a.name;
50    }
51
52    public  String name;
53
54    private int  age;
55
56    public  AAA birthday;
57
58    public  Object clone()
59    {
60       try
61       {
62             super .clone();
63             return super .clone();
64       } catch  (Exception e)
65       {
66             return null ;
67       }
68    }
69 }
70
71 public class  TestClone
72 {
73    public static void  main(String[] args)
74    {
75       AAA Day  = new  AAA( " test " );
76       DOG dog1  = new  DOG( " xiaogou " ,  2 , Day);
77       DOG dog2  =  (DOG) dog1.clone();
78       dog2.birthday  =  (AAA) dog1.birthday.clone(); // 特别注意这里
79       dog1.birthday.name  = " 333 " ;
80       System.out.println(dog1.getBirth(dog1.birthday));
81       System.out.println(dog2.getBirth(dog2.birthday));
82    }
83 }
84

运行结果：
333
test
这样基本就达到了我们当初的母的。

但是明显的这种方法还是有许多不足，人们总是希望一个clone就是对象直接克隆。而上面还要对对象中的对象递归使用clone。下面提供一种更高级点的做法：

1 import  java.io. * ;
2
3 class  AAA  implements  Serializable
4 {
5    public  AAA(String name)
6    {
7       this .name  =  name;
8    }
9
10    public  String name;
11 }
12
13 class  DOG  extends  SerialCloneable
14 {
15    public  DOG(String name,  int  age, AAA birthday)
16    {
17       this .name  =  name;
18       this .age  =  age;
19       this .birthday  =  birthday;
20    }
21
22    public  String getName()
23    {
24       return  name;
25    }
26
27    public int  getAge()
28    {
29       return  age;
30    }
31
32    public  AAA getBirthday()
33    {
34       return  birthday;
35    }
36
37    public  String getBirth(AAA a)
38    {
39       return  a.name;
40    }
41
42    public  String name;
43
44    private int  age;
45
46    public  AAA birthday;
47
48    public  Object clone()
49    {
50       try
51       {
52             super .clone();
53             return super .clone();
54       } catch  (Exception e)
55       {
56             return null ;
57       }
58    }
59 }
60
61 public class  TestClone
62 {
63    public static void  main(String[] args)
64    {
65       AAA Day  = new  AAA( " test " );
66       DOG dog1  = new  DOG( " xiaogou " ,  2 , Day);
67       DOG dog2  =  (DOG) dog1.clone();
68       // dog2.birthday = (AAA) dog1.birthday.clone();
69       dog1.birthday.name  = " 333 " ;
70       System.out.println(dog1.getBirth(dog1.birthday));
71       System.out.println(dog2.getBirth(dog2.birthday));
72    }
73 }
74
75 class  SerialCloneable  implements  Cloneable, Serializable
76 {
77    public  Object clone()
78    {
79       try
80       {
81          ByteArrayOutputStream bout  = new  ByteArrayOutputStream();
82          ObjectOutputStream out  = new  ObjectOutputStream(bout);
83          out.writeObject( this );
84          out.close();
85          ByteArrayInputStream bin  = new  ByteArrayInputStream(bout
86                   .toByteArray());
87          ObjectInputStream in  = new  ObjectInputStream(bin);
88          Object ret  =  in.readObject();
89          in.close();
90             return  ret;
91       } catch  (Exception e)
92       {
93             return null ;
94       }
95    }
96 }
97

输出：
333
test

上面的代码用序列化与反序列化实现了对象拷贝。比较通用。但是得注意的是其中的类得implements Serializable。

论坛模式推荐收藏分享给好友推荐到圈子管理

TAG:

justforregister 发布于2008-05-01 20:16:13: nice job

greenflute发布于2008-05-01 23:41:13

svsechen 发布于2008-05-04 01:13:23: 提问.
要进入IT企业或公司学历和技能那个更重要?

.@Xf/YnZX{space.itpub.net只有技能而没有好的学历行吗?
\!ZZ2m([0Oo^ITPUB个人空间只有学历而没有好的技能行吗?"W}yW(k+Z
问题补充：如果没有很好的学历,但有较好的技能在进IT业时会不会遇到麻烦或者用人单位根本不要.

进入论坛，查看全部评论

JAVA 对象拷贝

用户菜单

我的栏目

标题搜索

日历

我的存档

数据统计

RSS订阅