一、对象的浅克隆
（1）需要克隆类需要重写Object类的clone方法，并且实现Cloneable接口（标识接口，无需实现任何方法）
（2）当需要克隆的对象中维护着另外一个引用对象，浅克隆不会克隆另外一个引用对下，而是直接复制维护的另外一个引用对象的地址。
（3）对象的浅克隆也不会调用到构造方法。
以下为对象的浅克隆的一个例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
package com.clone;
import java.io.Serializable;
/**
* Description:
* 实现了Cloneable接口，并重写Object类的clone方法。
*
* @author lee
* */
public class CloneDemo1 implements Cloneable,Serializable{
//该克隆类封装的信息
public int id;
public String name;
public Address address;
/**
* Desciption:
* 默认构造器
*
* */
public CloneDemo1(){}
/**
* Description:
* 初始化id，name的构造器
*
* @param id id
* @param name 名字
* @param address 地址
* */
public CloneDemo1(int id, String name, Address address){
this.id=id;
this.name=name;
this.address = address;
}
/**
* Descriptin:
* 重写Object类的clone方法。
* if the object's class does not support the Cloneable interface.
* Subclasses that override the clone method can also throw this exception
* to indicate that an instance cannot be cloned.
*
* @throws CloneNotSupportedException
* */
@Override
public Object clone() throws CloneNotSupportedException{
return super.clone();
}
/**
* Description:
* 重写toString方法
*
* @return "id="+id+", name="+name
* */
@Override
public String toString(){
return "id="+id+", name="+name+", address:"+address.getAddress();
}
/**
* Description:
* 主方法
*
* */
public static void main(String[] args) throws CloneNotSupportedException{
CloneDemo1 c1 = new CloneDemo1(1,"c1",new Address("北京"));
//c2 复制了c1的地址，并没有复制整个c1对象
CloneDemo1 c2 = c1;
//c3 对象的浅克隆，复制了整个对象
CloneDemo1 c3 = (CloneDemo1)c1.clone();
//当对象c1改变其name或者id的时候，c2也会自动改变。
//因为c2只是复制了c1的地址，并非复制了c1的整个对象。
//相应的c3则不会随着c1改变而改变，意味着c3将c1整个对象克隆一份出来。
//当是，对象的浅克隆不会克隆被克隆对象当中的引用对象。
//因此c1改变其中的Address的引用对象时，c2，c3也会跟着改变。
c1.setName("cc");
c1.address.setAddress("上海");
System.out.println(c1+"\n"+c2+"\n"+c3);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/**
* Description:
* 一个封装着地址的类
*
* @author lee
* */
class Address implements Serializable{
public String address;
/**
* Description:
* 默认构造器
*
* */
public Address(){}
/**
* Description:
* 初试化address
*
* @param address 地址
* */
public Address(String address){
this.address = address;
}
//address的set和get方法
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
|
二、对象的深克隆
就是利用对象的输入输出流把对象写到文件上，再读取对象的信息，这就是对象的深克隆。
由于对象的浅克隆不会克隆被克隆对象其中的引用对象，而是直接复制其地址。因此，要克隆被克隆对象当中的引用类型则需要对象的深克隆。
而对象的深克隆使用的的对象序列化输入输出。
代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
package com.clone;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* Description:
* 实现对象的深克隆
*
* @author lee
* */
public class CloneDemo2 {
/**
* Description:
* 将对象输出到一个文件当中。
*
* @param c 需要被写到文件当中的对象。
* */
public static void writeObject(CloneDemo1 c){
ObjectOutputStream out = null;
try{
//将对象输出在一个object.txt文件当中
out = new ObjectOutputStream(new FileOutputStream("./object.txt"));
out.writeObject(c);
}catch(IOException e){
System.out.println("写入对象的时候发生了错误。");
e.printStackTrace();
}finally{
//关闭资源
try{
out.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
/**
* Description：
* 从文件中读取出一个对象来，并返回。
*
* @return c 返回一个对象。
* */
public static CloneDemo1 readObject(){
CloneDemo1 c = null;
ObjectInputStream input = null;
try{
//从object.txt文件中读取一个对象出来
input = new ObjectInputStream(new FileInputStream("./object.txt"));
c = (CloneDemo1)input.readObject();
}catch(IOException | ClassNotFoundException e){
e.printStackTrace();
System.out.println("读取对象的时候发生了错误。");
}finally{
//关闭资源
try{
input.close();
}catch(IOException e){
e.printStackTrace();
}
}
return c;
}
/**
* Description：
* 主方法
*
* @throws CloneNotSupportedException
* */
public static void main(String[] args) throws CloneNotSupportedException {
CloneDemo1 c1 = new CloneDemo1(1,"c1",new Address("北京"));
//c2 对象的浅克隆
CloneDemo1 c2 = (CloneDemo1)c1.clone();
//c3对象的深克隆
writeObject(c1);
CloneDemo1 c3 = readObject();
//因为对象的深克隆同时也克隆了被克隆对象维护的另外一个对象
//所以，当c1改变其当中的维护的另外一个对象的时候，c3不会随之改变。
//而c2位浅克隆，其维护的另外一个对象只是复制了c1维护的对象的地址，因此会随着c1的改变而改变。
c1.address.setAddress("上海");
System.out.println(c1+"\n"+c2+"\n"+c3);
}
}
|
对象的序列化，是需要实现Serializable接口的。
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！
原文链接：http://blog.csdn.net/qq1131410679/article/details/65934698