对浅拷贝和深拷贝的理解------拷贝两个相互引用的对象
Object类的 clone() 方法能实现对对象的浅拷贝, 如果需要对对象实现深拷贝, 则需要实现Cloneable接口并重写 clone() 方法, 且方法访问权限为 public.
我们来看看当两个对象相互引用时, 实现浅拷贝和深拷贝的情况:
Man类中存在一个Woman引用类型的实例属性, Woman类中也存在一个 Man引用类型的实例属性. 使Man类实现 Cloneable接口并且重写clone() 方法, 对 Man对象进行浅拷贝, 来看看原对象的副本中的Woman引用变量到底引用的是什么.
创建Man类和Woman类
public class Man implements Cloneable{
private int m;
private Woman woman;
public int getM() {
return m;
}
public void setM(int m) {
this.m = m;
}
public Woman getWoman() {
return woman;
}
public void setWoman(Woman woman) {
this.woman = woman;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Woman {
private int w;
private Man man;
public int getW() {
return w;
}
public void setW(int w) {
this.w = w;
}
public Man getMan() {
return man;
}
public void setMan(Man man) {
this.man = man;
}
}下面是测试对Man对象进行浅拷贝:
public static void main(String[] args) throws CloneNotSupportedException {
//创建一个Man对象,并设置成员变量初始化值
Man man=new Man();
man.setM(10);
Woman woman=new Woman();
woman.setW(11);
man.setWoman(woman);//将Man对象中的引用变量指向w1对象
woman.setMan(man);//同理,将Woman对象中的引用变量指向m1对象
//对man对象实现浅拷贝
Man man2= (Man) man.clone();
System.out.println(man==man2);//输出false
System.out.println(man.getWoman()==man2.getWoman());//true
System.out.println(man.getWoman().getMan()==man2.getWoman().getMan());//true
System.out.println(man);//com.clonedemo.Man@66d3c617
System.out.println(man2.getWoman().getMan());//com.clonedemo.Man@66d3c617
}
}由上面的代码可以看出, 对man对象进行浅拷贝, man2与man对象指向不同的对象. 并且引用类型woman指向同一个Woman对象woman. 这完全符合浅拷贝的概念. 还可以发现, 两个Man对象中的woman对象中的man引用类型指向的是同一个对象, 这个对象就是我们在程序中为 woman对象中的man引用初始化的 man对象. 图解:
那如何对Man对象实现深拷贝呢
我们先来看看重写Man中的clone() 方法并且Woman类也实现Cloneable接口实现重写clone()方法实现浅拷贝:
public class Man implements Cloneable{
private int m;
private Woman woman;
public int getM() {
return m;
}
public void setM(int m) {
this.m = m;
}
public Woman getWoman() {
return woman;
}
public void setWoman(Woman woman) {
this.woman = woman;
}
@Override
public Object clone() throws CloneNotSupportedException {
Man man2= (Man) super.clone();
man2.setWoman((Woman) woman.clone());
return man2;
}
}
public class Woman implements Cloneable{
private int w;
private Man man;
public int getW() {
return w;
}
public void setW(int w) {
this.w = w;
}
public Man getMan() {
return man;
}
public void setMan(Man man) {
this.man = man;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
进行拷贝测试:
@Test
public void test() throws CloneNotSupportedException {
Man man=new Man();
Woman woman=new Woman();
man.setWoman(woman);
woman.setMan(man);
//对man对象进行深拷贝
Man man2= (Man) man.clone();
System.out.println(man==man2);//false
System.out.println(man.getWoman()==man2.getWoman());//false
System.out.println(man.getWoman().getMan()==man2.getWoman().getMan());//true
System.out.println(man);//com.clonedemo.Man@1efed156
System.out.println(man2.getWoman().getMan());//com.clonedemo.Man@1efed156
}我们可以看到, 现在原对象man和拷贝对象man2中的 woman引用指向不同的 Woman对象. 同时也发现两个Woman对象中的实例属性man引用依旧指向同一个Man对象. 也就是都引用到 man原对象上. 这是因为在 Woman的clone()方法中, 只是简单调用了Object类的clone() 方法, 实现的是对Woman对象的浅拷贝. 也就是说并没有对Woman对象中的man引用变量进行对象复制, 两个Woman对象中的 man引用依然引用到同一个对象上. 这也很符合浅拷贝的概念.
看一下图解:
那么如何才能实现真正的深拷贝呢. (使Man副本与Woman副本对象也相互引用)
我们再对Man类的clone()方法进行修改, 实现深拷贝. Woman类不做修改代码如下:
public class Man implements Cloneable{
private int m;
private Woman woman;
public int getM() {
return m;
}
public void setM(int m) {
this.m = m;
}
public Woman getWoman() {
return woman;
}
public void setWoman(Woman woman) {
this.woman = woman;
}
@Override
public Object clone() throws CloneNotSupportedException {
Man man2= (Man) super.clone();
Woman wClone= (Woman) woman.clone();
wClone.setMan(man2);
man2.setWoman(wClone);
return man2;
}
}
public class Woman implements Cloneable{
private int w;
private Man man;
public int getW() {
return w;
}
public void setW(int w) {
this.w = w;
}
public Man getMan() {
return man;
}
public void setMan(Man man) {
this.man = man;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}再次进行测试:
@Test
public void test() throws CloneNotSupportedException {
Man man=new Man();
Woman woman=new Woman();
man.setWoman(woman);
woman.setMan(man);
//对man对象进行深拷贝
Man man2= (Man) man.clone();
System.out.println(man==man2);//false
System.out.println(man.getWoman()==man2.getWoman());//false
System.out.println(man.getWoman().getMan()==man2.getWoman().getMan());//false
System.out.println(man2.getWoman().getMan()==man2);//true
System.out.println(man);//com.clonedemo.Man@1efed156
System.out.println(man2);//com.clonedemo.Man@6737fd8f
System.out.println(man2.getWoman().getMan());//com.clonedemo.Man@6737fd8f
}我们这次可以发现副本对象man2中的 woman引用的对象是一个独立的副本对象, 而且此副本对象中的man引用, 也引用的是man2对象, 这次可以说是真正实现了"深拷贝".
图解如下:
