Java中的深拷贝和浅拷贝
深拷贝与浅拷贝的区别
1．浅复制与深复制概念
⑴浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，只复制对象的基本类型，对象类型仍属于原来的引用.。
⑵深复制（深克隆）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，不仅复制对象的基本类，同时也复制原对象中的对象。就是说完全是新对象产生的。
2．Java的clone（）方法
⑴clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。
⑵Java中对象的克隆
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
②在派生类中覆盖基类的clone()方法，并声明为public。
③在派生类的clone()方法中，调用super.clone()。
④在派生类中实现Cloneable接口。
请看如下代码：
1 class Student implements Cloneable
2 {
3 String name;
4 int age;
5 Student(String name,int age)
6 {
7 this.name=name;
8 this.age=age;
9 }
10 public Object clone()
11 {
12 Object o=null;
13 try
14 {
15 o=(Student)super.clone();//Object中的clone()识别出你要复制的是哪一个对象。
16 }
17 catch(CloneNotSupportedException e)
18 {
19 System.out.println(e.toString());
20 }
21 return o;
22 }
23
24
25 public static void main(String[] args)
26 {
27 Student s1=new Student("zhangsan",18);
28 Student s2=(Student)s1.clone();
29 s2.name="lisi";
30 s2.age=20;
31 System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2后，不影响学生1的值。
32 }
33 }
说明：
①为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。
②继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明之。
1 class Professor implements Cloneable
2 {
3 String name;
4 int age;
5 Professor(String name,int age)
6 {
7 this.name=name;
8 this.age=age;
9 }
10 public Object clone() throws CloneNotSupportedException{
11 return super.clone();
12 }
13 }
14 class Students implements Cloneable
15 {
16 String name; //常量对象。
17 int age;
18 Professor p; //学生1和学生2的引用值都是一样的。
19 Students(String name,int age,Professor p)
20 {
21 this.name=name;
22 this.age=age;
23 this.p=p;
24 }
25 public Object clone()
26 {
27 Students o=null;
28 try
29 {
30 o=(Students)super.clone();
31 o.p=(Professor)p.clone();
32 }
33 catch(CloneNotSupportedException e)
34 {
35 System.out.println(e.toString());
36 }
37
38 return o;
39 }
40
41 public static void main(String[] args)
42 {
43 Professor p=new Professor("wanGWu",50);
44 Students s1=new Students("zhangsan",18,p);
45 Students s2=(Students)s1.clone();
46 s2.p.name="lisi";
47 s2.p.age=30;
48 System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//学生1的教授成为lisi,age为30。
49 }
50 }
那应该如何实现深层次的克隆，即修改s2的教授不会影响s1的教授？代码改进如下。
改进使学生1的Professor不改变（深层次的克隆）
1 class Professor implements Cloneable
2 {
3 String name;
4 int age;
5 Professor(String name,int age)
6 {
7 this.name=name;
8 this.age=age;
9 }
10 public Object clone()
11 {
12 Object o=null;
13 try
14 {
15 o=super.clone();
16 }
17 catch(CloneNotSupportedException e)
18 {
19 System.out.println(e.toString());
20 }
21 return o;
22 }
23 }
24 class Student implements Cloneable
25 {
26 String name;
27 int age;
28 Professor p;
29 Student(String name,int age,Professor p)
30 {
31 this.name=name;
32 this.age=age;
33 this.p=p;
34 }
35 public Object clone()
36 {
37 Student o=null;
38 try
39 {
40 o=(Student)super.clone();
41 }
42 catch(CloneNotSupportedException e)
43 {
44 System.out.println(e.toString());
45 }
46 o.p=(Professor)p.clone();
47 return o;
48 }
49
50 public static void main(String[] args)
51 {
52 Professor p=new Professor("wangwu",50);
53 Student s1=new Student("zhangsan",18,p);
54 Student s2=(Student)s1.clone();
55 s2.p.name="lisi";
56 s2.p.age=30;
57 System.out.println("name="+s1.p.name+","+"age="+s1.p.age); //学生1的教授不改变。
58 }
59 }
3．利用串行化来做深复制
把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。
在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。
如下为深复制源代码。
1 public Object deepClone() throws IOException, ClassNotFoundException
2 {
3 //将对象写到流里
4 ByteArrayOutputStream bo=new ByteArrayOutputStream();
5 ObjectOutputStream oo=new ObjectOutputStream(bo);
6 oo.writeObject(this);
7 //从流里读出来
8 ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
9 ObjectInputStream oi=new ObjectInputStream(bi);
10 return(oi.readObject());
11 }
这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。上例代码改进如下。
1 class Professor implements Serializable{
2 String name;
3 int age;
4 Professor(String name,int age)
5 {
6 this.name=name;
7 this.age=age;
8 }
9 }
10 class Student implements Serializable
11 {
12 String name;//常量对象。
13 int age;
14 Professor p;//学生1和学生2的引用值都是一样的。
15 Student(String name,int age,Professor p)
16 {
17 this.name=name;
18 this.age=age;
19 this.p=p;
20 }
21 public Object deepClone() throws IOException,OptionalDataException,ClassNotFoundException{
22 //将对象写到流里
23 ByteArrayOutputStream bo=new ByteArrayOutputStream();
24 ObjectOutputStream oo=new ObjectOutputStream(bo);
25 oo.writeObject(this);
26 //从流里读出来
27 ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
28 ObjectInputStream oi=new ObjectInputStream(bi);
29 return(oi.readObject());
30 }
31
32
33 public static void main(String[] args) throws OptionalDataException, IOException, ClassNotFoundException
34 {
35 Professor p=new Professor("wangwu",50);
36 Student s1=new Student("zhangsan",18,p);
37 Student s2=(Student)s1.deepClone();
38 s2.p.name="lisi";
39 s2.p.age=30;
40 System.out.println("name="+s1.p.name+","+"age="+s1.p.age); //学生1的教授不改变。
41 }
42 }
