实例代码分析cloneable的使用

分析之前先了解两个概念

1.浅拷贝

  什么是浅拷贝
   浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象

   如图：

    

SourceObject有一个int类型的属性 "field1"和一个引用类型属性"refObj"（引用ContainedObject类型的对象）。当对SourceObject做浅拷贝时，创建了CopiedObject，它有一个包含"field1"拷贝值的属性"field2"以及仍指向refObj本身的引用。由于"field1"是基本类型，所以只是将它的值拷贝给"field2"，但是由于"refObj"是一个引用类型, 所以CopiedObject指向"refObj"相同的地址。因此对SourceObject中的"refObj"所做的任何改变都会影响到CopiedObject

2.深拷贝

  深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大，如下图：

  

图中，SourceObject有一个int类型的属性 "field1"和一个引用类型属性"refObj1"（引用ContainedObject类型的对象）。当对SourceObject做深拷贝时，创建了CopiedObject，它有一个包含"field1"拷贝值的属性"field2"以及包含"refObj1"拷贝值的引用类型属性"refObj2" 。因此对SourceObject中的"refObj"所做的任何改变都不会影响到CopiedObject

如何实现浅拷贝呢？看代码：

public class User implements Cloneable{
public int age;
public String name;

public User(int age, String name) {
this.age = age;
this.name = name;
}

@Override
protected Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}

@Override
public String toString() {
return "User [age=" + age + ", name=" + name + ", hashCode()=" + hashCode() + "]";
}

}

public class CloneTest {


public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
User u1 = new User(15, "Tom");
User u2 = u1;
User u3 = (User)u1.clone();
System.out.println("u1==u2=" + (u1 == u2));
System.out.println("u1==u3=" + (u1 == u3));
System.out.println("u1.equals(u2)=" + (u1.equals(u2)));
System.out.println("u1.equals(u3)=" + (u1.equals(u3)));
System.out.println("u1:" + u1.toString() + "\nu3=" + u3.toString());
u2.age = 20;
u3.age = 30;
System.out.println("u1:" + u1.toString() + "\nu3=" + u3.toString());
}
}

看运行效果：

u1==u2=true//说明指向同一个引用
u1==u3=false//说明是两个不同引用,clone了一份
u1.equals(u2)=true//说明指向同一个引用
u1.equals(u3)=false//说明是两个不同引用,clone了一份
u1:User [age=15, name=Tom, hashCode()=366712642]
u3=User [age=15, name=Tom, hashCode()=1829164700]//基本列表与u1值相同，u1、u3两个对象
had mod u1:User [age=20, name=Tom, hashCode()=366712642]//u2跟u1是同一个引用，所以修改后对u1有影响
u3=User [age=30, name=Tom, hashCode()=1829164700]//u2跟u1不是同一个引用，所以修改后对u1没有影响

接着看下面的代码：

public class ShallwCopy implements Cloneable {
    User user;
    long a;
    ShallwCopy(User u, long b) {
        user = u;
        a = b;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

@Override
public String toString() {
return "ShallwCopy [user=" + user + ", a=" + a + ", hashCode()=" + hashCode() + "]";
}
    
}

public class CloneTest {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
User u1 = new User(15, "Tom");
User u2 = u1;
User u3 = (User)u1.clone();
System.out.println("==============shallow copy=====================");
ShallwCopy a1 = new ShallwCopy(u1, 10000);
ShallwCopy a2 = a1;
ShallwCopy a3 = (ShallwCopy) a1.clone();

System.out.println("a1==a2=" + (a1 == a2));
System.out.println("a1==a3=" + (a1 == a3));
System.out.println("a1.equals(a2)=" + (a1.equals(a2)));
System.out.println("a1.equals(a3)=" + (a1.equals(a3)));
System.out.println("a1.user==a3.user=" + (a1.user == a3.user));
System.out.println("a1:" + a1.toString() + "\na3=" + a3.toString());
a3.user.age = 40;
System.out.println("a1:" + a1.toString() + "\na3=" + a3.toString());

}

}

运行结果：

==============shallow copy=====================
a1==a2=true
a1==a3=false
a1.equals(a2)=true
a1.equals(a3)=false
a1.user==a3.user=true
a1:ShallwCopy [user=User [age=20, name=Tom, hashCode()=366712642], a=10000, hashCode()=2018699554]
a3=ShallwCopy [user=User [age=20, name=Tom, hashCode()=366712642], a=10000, hashCode()=1311053135]
had mod a1:ShallwCopy [user=User [age=40, name=Tom, hashCode()=366712642], a=10000, hashCode()=2018699554]
a3=ShallwCopy [user=User [age=40, name=Tom, hashCode()=366712642], a=10000, hashCode()=1311053135]

可以看出a1与a3是两个对象，但是引用的user对象确是同一个，这就如上图所说的指向了同一个对象refObj，这时候a3修改user的值时，a1也相应的发生了改变。

那怎么处理才能保证修改a3，而不修改a1的user引用呢，这就是下面说的深拷贝了，看代码：

public class DeepCopy implements Cloneable {
    User user;
    long a;
    DeepCopy(User u, long b) {
        user = u;
        a = b;
    }


    @Override
    protected Object clone() throws CloneNotSupportedException {
   //  DeepCopy d = (DeepCopy) super.clone();
   // d.user = (User) d.user.clone();
    DeepCopy d = new DeepCopy((User)user.clone(), a);

        return d;
    }


@Override
public String toString() {
return "DeepCopy [user=" + user + ", a=" + a + ", hashCode()=" + hashCode() + "]";
}
}

仔细看下，其实这个类跟上面的ShallowCopy不同的地方在 clone()方法

shawllow的clone方法:return super.clone();

而这个类的clone方法：return new DeepCopy((User)user.clone(), a);

测试类调用：

public class CloneTest {


public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
User u1 = new User(15, "Tom");
User u2 = u1;
User u3 = (User)u1.clone();

System.out.println("=============deep copy=====================");

DeepCopy d1 = new DeepCopy(u1, 10000);
DeepCopy d2 = d1;
DeepCopy d3 = (DeepCopy) d1.clone();

System.out.println("d1==d2=" + (d1 == d2));
System.out.println("d1==d3=" + (d1 == d3));
System.out.println("d1.equals(d2)=" + (d1.equals(d2)));
System.out.println("d1.equals(d3)=" + (d1.equals(d3)));
System.out.println("d1.user==d3.user=" + (d1.user == d3.user));
System.out.println("d1:" + d1.toString() + "\nd3=" + d3.toString());
d3.user.age = 50;
System.out.println("had mod d1:" + d1.toString() + "\nd3=" + d3.toString());

}

}

看下运行结果：

=============deep copy=====================
d1==d2=true
d1==d3=false
d1.equals(d2)=true
d1.equals(d3)=false
d1.user==d3.user=false
d1:DeepCopy [user=User [age=40, name=Tom, hashCode()=366712642], a=10000, hashCode()=118352462]
d3=DeepCopy [user=User [age=40, name=Tom, hashCode()=1550089733], a=10000, hashCode()=865113938]
had mod d1:DeepCopy [user=User [age=40, name=Tom, hashCode()=366712642], a=10000, hashCode()=118352462]
d3=DeepCopy [user=User [age=50, name=Tom, hashCode()=1550089733], a=10000, hashCode()=865113938]

可以看到d1与d3的user不是同一个引用对象了，所以修改d3的user时，也不会引用到d1的user

好了，以上是个人对cloneable接口与clone方法的代码实测，如有讲的不正确的地方，欢迎指出。