漫谈deepcopy（深拷贝）和shallowcopy（浅拷贝）

原型模式要求用深拷贝(复制/克隆)的方式实现，对这个概念很模糊。在自己查了相关资料后，我将从三个方面讲述深浅拷贝：

图形表述深浅拷贝区别及特点

Object类中的clone()方法实现深浅拷贝

实际应用中深浅拷贝区别

一 图形表述深浅拷贝区别及特点

前提：深浅拷贝基本上都是讨论引用类型的变量(对象，String类等)，对基本数据类型的变量，深浅拷贝都是要复制的。下面以图形的形式表述深浅拷贝的区别：



浅拷贝：只复制当前的对象，对该对象内部的引用（其他类对象作为自己的元素-也叫对其他对象的引用）不能复制（在堆内存中从新创建空间，内容相同，但地址不同）。

深拷贝：对对象内部的引用均复制，是创建一个新的实例，并复制实例。

简言之：是否复制了子对象。/修改了克隆后的对象的属性值，影响到原对象-浅拷贝；不影响叫深拷贝。

二 Object类中的clone()方法实现深浅拷贝

2.1 java内存模型

Java的内存模型主要参考http://blog.csdn.net/qh_java/article/details/9084091这篇博客，写的非常详细，受益匪浅。这里只介绍栈区和堆区。

栈：存放基本类型的变量数据，局部变量，和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）

堆：用来存放动态产生的数据，比如new产生的对象，数组。注意创建出来的对象只包含属于各自的成员变量，并不包括成员方法。因为同一个类的对象拥有各自的成员变量，存储在各自的堆中，但是他们共享该类的方法，并不是每创建一个对象就把成员方法复制一次。

2.2 “==”和equals()区别

对于基本数据类型(int,float,double,byte,short,long,boolean,char)，只能用==

对于基本数据类型的封装类(Boolean,Integer,Long,Float,Double)，==比较的是指向对象的地址，比较的是栈内存中存放的对象的引用（地址），equals比较的是值。

如果是类对象，那么在对象的类没有重写equals()方法时，==和equals都是比较地址。如果覆盖了equals()方法，根据实际情况比较。

String类，Data类都重写了equals方法，所以==比较地址，equals比较值。

另外equals满足四大特性：自反性：x.equals(x)为true; 对称性：y.equals(x)为真时，x.equals(y)也为真；传递性：x.equals(x)为真，y.equals(z)为真，那么x.equals(z)为真；非空性：对任何非空的引用值，x.equals(null)为假。

2.3 clone()方法的使用

Java中父类java.lang.Object提供了clone()方法，但考虑到安全性问题，一方面将clone()方法的访问级别设置为protected类型，限制外部类访问，另一方面，强制需要提供clone功能的子类实现java.lang.Cloneable接口。总结就是如果一个类需要被克隆，该类需要实现clone方法和实现Cloneable接口，缺一不可。

在java中使用clone()方法如何判别深浅拷贝呢，就是判断拷贝后的对象是否相等，即判断两对象的地址是否相同。B=clone(A),A==B为真否。以下图为例：p1是对象1的引用变量，对象1含有对对象2和对象3的引用；p2是p1的clone()。执行p1.对象1==p2.对象1为ture，因为他们共同保存对象2的引用。p1==p2为false,因为指向不同的地址。下面从4个角度说明clone()如何体现深浅拷贝。



Clone()方法只复制当前对象，对于没有内部引用的对象，p2克隆p1后，两个对象指向不同的地址，p1==p2操作返回false。

package clone1;
class  Person implements Cloneable{
int age;
String name;
public  Person(int a, String b){
age=a;
name=b;
}
public Person(Person p){
this.age=p.age;
this.name=p.name;
}
@Override
public Object clone() {
Person per=null;
try {
per=(Person)super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return  per;
}

}
public class Body {
public static void main(String[] args){
Person p1=new Person(10,"wang");
Person p2 = (Person) p1.clone();
System.out.println(p1);//输出堆内存的地址
System.out.println(p2);
System.out.println(p1==p2);
}

}
}
输出：
P1地址:clone1.Person@6d6e1eff
P2地址:clone1.Person@74d4db38
P1==p2:false

当Person类含有其他对象的引用时（含有其他类的对象），增加一个类student，内含成绩grade这个元素，该类对象要作为Person类的成员，添加内部引用。调用clone方法会发现其他对象的引用并没有克隆成功。

package clone1;
class Student{
String grade;
public Student(){
}
public void  setGrade(String a){
this.grade=a;
}
}
class  Person implements Cloneable{
int age;
String name;
Student  grades;
public void setGrades(Student gra){
this.grades=gra;
}
public  Person(int a, String b,Student gra){
age=a;
name=b;
this.grades=gra;
}
public Person(Person p){
this.age=p.age;
this.name=p.name;
//this.grade1=p.grade;
}
@Override
public Object clone() {
Person per=null;
try {
per=(Person)super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return  per;
}
}
public class Body {
public static void main(String[] args){
// TODO Auto-generated method stub
Student stu=new Student();
stu.setGrade("100");
Person p1=new Person(10,"wang",stu);
Person p2 = (Person)  p1.clone();
System.out.println(p1.grades==p2.grades);
}
}
结果：p1.grades==p2.grades：true

执行

stu.setGrade("200");
System.out.println(p2.grades.grade);
System.out.println(p1.grades.grade);

后，会发现，两个结果相同，说明指向同一个对象，一变全变。这就表明grade对象并没有拷贝，p1和p2存放的是grade的引用。地址相同，这是浅拷贝，也就是说对于不重写的clone()方法，默认是浅拷贝。

下面仔细的重写下clone方法，变成深拷贝，不再是修改克隆后的对象的属性值，影响到原对象。

package clone1;
class Student implements Cloneable{
String grade;
public Student(){

}
public void  setGrade(String a){
this.grade=a;
}
public Object clone(){
Student stu=null;
try {
stu=(Student)super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return stu;
}
}
class  Person implements Cloneable{
int age;
String name;
Student  grades;
public void setGrades(Student gra){
this.grades=gra;
}
public  Person(int a, String b,Student gra){
age=a;
name=b;
this.grades=gra;
}
public Person(Person p){
this.age=p.age;
this.name=p.name;
this.grades=p.grades;
}
@Override
public Object clone() {
Person per=null;
try {
per=(Person)super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
per.grades=(Student)grades.clone();//深拷贝：就是对引用的对象单独拷贝一次哦。
return  per;
}

}
public class Body {
public static void main(String[] args){
// TODO Auto-generated method stub
Student stu=new Student();
stu.setGrade("100");
Person p1=new Person(10,"wang",stu);
Person p2 = (Person)  p1.clone();
System.out.println(p1.grades==p2.grades);
}

}

结果：p1.grades==p2.grades:false

执行：

stu.setGrade("200");
System.out.println(p2.grades.grade);
System.out.println(p1.grades.grade);

发现执行结果为200和100，说明的确不是指向同一个对象了(相同引用)，而是单独指向，不再一变全变。

三 实际应用中深浅拷贝区别

如果拆开来对对象2的元素依次赋值，这样的肯定就是深度复制了。例如p2.grades=new Student(){}因为这样是明显的创建新实例来进行赋值，没有传递引用等操作。

Person a1=new Person(“yellow”,new Person(“li”,10,F));

Person a2=new Person(a1) //若a1中没有引用，那肯定地址不同，若有对象引用，这种方式不能对引用创建新的内存空间，保存引用。

Person a2=a1;//最显而易见的浅复制，全是引用。

本文主要参考以下两篇博客和设计模式书中的原型模型(Prototype)

http://blog.csdn.net/tounaobun/article/details/8491392

http://blog.csdn.net/zhangjg_blog/article/details/18369201