浅度拷贝：只复制一个对象，对象内部存在的指向其他对象数组或者引用则不复制。

深度拷贝：对象，对象内部的引用均复制。

具体我们通过例子分析一下：

class

Professor implements

Cloneable

//所有要进行克隆的对象所属的类必须实现java.lang.Cloneable接口

{

private

String pname;private int page;

public String getPname()

{return

pname;}

public void

setPname(String pname)

{this.pname

= pname;}

public int

getPage()

{return

page;}

public void

setPage(int page)

{this.page =

page;}

Professor(String

pname,int page)

{this.pname=pname;

this.page=page;

}

public

Object clone()

{Professor

p=null;

try

{p=(Professor)super.clone();

}

catch(Exception

e)

{e.printStackTrace();

}return p;}

public void

display()

{System.out.println("professor

Name:"+pname+";age:"+page);

}}

class

Student implements

Cloneable{

String

sname; int sage;

String

srollno; Professor

prof;

public

Student(String sname,int sage,Professor p)

{this.sname=sname;

this.sage=sage;

prof=p;

}

public Object

clone()

{Student

stud=null;

try{stud=(Student)super.clone();

//注意这里，我们做的只是浅复制，我们并没有对Student下的Professor做进一步复制。

其下的prof是一个引用，//这里我们仅仅拷贝了引用的地址，并没有对其中的属性进行拷贝。

}

catch(……)

{e.printStackTrace();

}return

stud;}

public void

display()

{System.out.println("student

Name is:"+sname+";Sage is:"+sage);

prof.display();}}

public class

Test {

public

static void main(String str[])

{Student

s=new Student("hope",22,new Professor("wei",43));

Student

s2=(Student)s.clone();

s.prof.setPage(111);

//这我们对prof引用进行了修改，由于该程序是浅复制

//，所以，我们修改s的同时，s2的改引用也发生了变化。

s.prof.setPname("11111");

s.display();

s2.display();

}}

其运行结果为：

student Name

is:hope;Sage is:22

professor Name:11111;age:111

student Name is:hope;Sage is:22

professor Name:11111;age:111

为了做到深层复制，我们修改代码如下：

public Object clone()

{Student stud=null;

try{stud=(Student)super.clone();

stud.prof=(Professor)prof.clone();//对其下层的引用也克隆一下。

}catch(……)

}return stud;}