1. Overiew
在实际编程中,我们经常会遇到这样一个情景:有一个对象A,存在属性方法,现在需要一个和A完全相同的新对象B,并且B的任何改动都不会影响到A中的值。那么,最常用的办法就是对A进行克隆。
2. How to Clone
在java.lang.Object中有一个clone方法,该方法的签名如下:
Java代码
protected native Object clone() throws CloneNotSupportedException;
该方法返回一个Object实例的拷贝,该实例拷贝具有:
1)拷贝对象是一个新对象而不是一个原对象引用。
2)拷贝的对象中包含的是原有对象信息,而不是对象初始化的信息(也就是说,拷贝过程没有调用构造函数)。
从第1条我们可以看出,拷贝的对象与原对象存在这样一种关系:
1. x.clone() != x will betrue
2. x.clone().getClass() == x.getClass() will betrue, but these are not absolute requirements
3. x.clone().equals(x) will betrue, but these are not absolute requirements
要实现克隆,必须满足一下三点:
1)类必须实现Cloneable接口
2)类必须重载Object类中的clone()方法
3)重载的clone()方法中,必须显示调用super.clone()。
我们看一下Cloneable接口的定义:
public interface Cloneable { }
Cloneable接口是不包含任何方法的,仅仅表示一个标志(类似Serializable接口),而且这个标志也是针对Object类中clone()方法的,如果clone类没有实现Cloneable接口,并调用了Object的clone()方法(也就是调用了super.Clone()方法),那么Object的clone()方法就会抛出CloneNotSupportedException异常。
按照要求,我们写一个克隆类的小例子:
public class DummyClone implementsCloneable{publicObject clone(){
DummyClone dc= null;try{
dc= (DummyClone)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}returndc;
}
}
3. Shadow Clone
首先,我们来看一个例子:ClassA没有实现Cloneable接口。ClassB存在ClassA的实例,实现了Cloneable接口,并重载了clone方法。ClassC实例化一个ClassB对象,然后克隆一个对象。
Java代码
classClassA {public inta;public voiddoubleA(){
a= a * 2;
}public ClassA(intaa){this.a =aa;
}publicString toString(){returnInteger.toString(a);
}
}class ClassB implementsCloneable{public intb;public ClassA ca = new ClassA(11);publicObject clone(){
ClassB cb= null;try{
cb= (ClassB)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}returncb;
}
}public classClassC {public static voidmain(String[] args) {
ClassB cb= newClassB();
cb.b= 222;
System.out.println("before clone : cb.b = " +cb.b);
System.out.println("before clone : cb.ca = " +cb.ca);//
ClassB cb2 =(ClassB)cb.clone();
cb2.b= 3333;
cb2.ca.doubleA();
System.out.println("========================");
System.out.println("after clone : cb.b = " +cb.b);
System.out.println("after clone : cb.ca = " +cb.ca);
System.out.println("========================");
System.out.println("after clone : cb2.b = " +cb2.b);
System.out.println("after clone : cb2.ca = " +cb2.ca);
}
}
输出结果如下:
Java代码
before clone :cb.b=222
before clone :cb.ca=11
========================
after clone :cb.b=222
after clone :cb.ca=22
========================
after clone :cb2.b=3333
after clone :cb2.ca=22
从结果我们看到,int类型的b被完全的克隆了,而ClassA类型的ca却没有被克隆。因为克隆后cb2对b的赋值不会影响原有cb中b的值,而调用cb2.ca.doubleA()方法后,对cb2.ca的改变同时改变了cb.ca,表明cb2.ca与cb.ca仅仅指向同一个对象的不同引用。从中可以看出,调用Object类中clone()方法产生的效果是:先在内存中开辟一块和原始对象一样的空间,然后原样拷贝原始对象中的内容。对基本数据类型,这样的操作是没有问题的,但对非基本类型变量clone后的变量和原始对象中相应的变量指向的是同一个对象。
这就是影子克隆。影子克隆,并没有完整的完成克隆,有时候这并不是我们想要的结果。我们有时需要,就像列子中调用cb2.ca.doubleA()方法时,不会对原对象产生改变,这时候我们就需要deep clone;
4. Deep Clone
要实现深度克隆,在上面的例子基础上,我们只需要这样修改即可:
class ClassA implementsCloneable{public inta;public voiddoubleA(){
a= a * 2;
}public ClassA(intaa){this.a =aa;
}publicString toString(){returnInteger.toString(a);
}publicObject clone(){
ClassA ca= null;try{
ca= (ClassA)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}returnca;
}
}class ClassB implementsCloneable{public intb;public ClassA ca = new ClassA(11);publicObject clone(){
ClassB cb= null;try{
cb= (ClassB)super.clone();
}catch(CloneNotSupportedException e) {
e.printStackTrace();
}
cb.ca=(ClassA)ca.clone();returncb;
}
}public classClassC {public static voidmain(String[] args) {
ClassB cb= newClassB();
cb.b= 222;
System.out.println("before clone : cb.b = " +cb.b);
System.out.println("before clone : cb.ca = " +cb.ca);//
ClassB cb2 =(ClassB)cb.clone();
cb2.b= 3333;
cb2.ca.doubleA();
System.out.println("========================");
System.out.println("after clone : cb.b = " +cb.b);
System.out.println("after clone : cb.ca = " +cb.ca);
System.out.println("========================");
System.out.println("after clone : cb2.b = " +cb2.b);
System.out.println("after clone : cb2.ca = " +cb2.ca);
}
}
输出结果:
before clone : cb.b = 222before clone : cb.ca= 11
========================after clone : cb.b= 222after clone : cb.ca= 11
========================after clone : cb2.b= 3333after clone : cb2.ca= 22
基本的数据类型可以自动的实现深度的克隆,然而并不是所有的类都可以进行深度的克隆,就比如String类,其类定义为final,且没有重载clone方法,我们就无法完成对String类的深度克隆。关于不可变对象的克隆,我们通常没有必要去克隆。
自己写的克隆:
packageclone;public class Employee3 implementsCloneable{privateString name;private intsalary;publicEmployee3()
{
}public Employee3(String name,intsalary)
{this.name=name;this.salary=salary;
}publicString getName()
{returnname;
}public intgetSalary()
{returnsalary;
}public Object clone() throwsCloneNotSupportedException
{
Employee3 emp=null;try{
emp= (Employee3)super.clone();
}catch(CloneNotSupportedException e) {//TODO Auto-generated catch block
e.printStackTrace();
}returnemp;
}
}
是这样的.object的clone()方法是protected。如果我们在测试类直接调用会报错:The method clone() from the type Object is not visible
因为他对Object.clone()进行了多态性的调用,而这个方法被声明是受保护的。
我们需要在Employee3类中添加clone()方法的一个只访问覆盖版本。只访问覆盖版本没有添加逻辑,他只是放松了对你的代码的访问限制public。记住覆盖的方法的访问限制不能比基类方法更严格,但是可以更宽松。
public classCloner {public static void main(String[] args) throwsCloneNotSupportedException
{
Employee3 e=new Employee3("Dolly",1000);
System.out.println(e);
System.out.println("the employee's name is "+e.getName());
System.out.println("the employee's salary is "+e.getSalary());/*Type mismatch: cannot convert from Object to Employee3
* *
*低---》高 强制转换*/Employee3 eClone=(Employee3)e.clone();
System.out.println(eClone);
System.out.println("the employee's name is "+eClone.getName());
System.out.println("the employee's salary is "+eClone.getSalary());
}
}
输出:
clone.Employee3@c17164
the employee's name is Dolly
the employee's salary is 1000
clone.Employee3@1fb8ee3 与前面的不同,说明不是同一个对象
the employee's name is Dolly
the employee's salary is 1000