1.为什么要用 clone?
在实际编程过程中,我们常常要遇到这种情况:
有一个对象 A,在某一时刻 A 中已经包含了一些有效值,此时可能会需要一个和 A 完全相同新对象 B,并且此后对 B 任何改动都不会影响到 A 中的值,也就是说,A 与 B 是两个独立的对象,但 B 的初始值是由 A 对象确定的。
在 Java 语言中,用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径,但实现 clone()方法是其中最简单,也是最高效的手段。
2.new 一个对象的过程和 clone 一个对象的过程区别
new对象的过程
- new 操作符的本意是分配内存。程序执行到 new 操作符时,首先去看 new 操作符后面的类型,因为知道了类型,才能知道要分配多大的内存空;
- 分配完内存之后,再调用构造函数,填充对象的各个域,这一步叫做对象的初始化;
- 构造方法返回后,一个对象创建完毕,可以把他的引用(地址)发布到外部,在外部就可以使用这个引用操纵这个对象。
clone对象的过程
- clone 在第一步是和 new 相似的,都是分配内存,调用 clone 方法时,分配的内存和原对象相同
- 然后再使用原对象中对应的各个域,填充新对象的域;
- clone 方法返回后,一个新的相同的对象被创建,同样可以把这个新对象的引用发布到外部。
对比上述过程,我们发现,第一步和第三步都差不多,区别在于第二步的时候,new使用构造方法填充对象的各个域,clone使用原对象中的各个域去填充新对象的域。
3.clone 对象的使用
3.1.复制对象和复制引用的区别
//注意:person没有重写toString方法
Person p = new Person(26, "hutao");
Person p1 = p;
System.out.println(p);
System.out.println(p1);
当 Person p1 = p;执行之后, 是创建了一个新的对象吗? 首先看打印结果:
com.hutao.Person@2f9ee1ac
com.hutao.Person@2f9ee1ac
可以看出,打印的地址值是相同的,既然地址都是相同的,那么肯定是同一个对象。p 和 p1 只是引用而已,他们都指向了一个相同的对象 Person(26, “hutao”) 。 可以把这种现象叫做引用的复制。
上面代码执行完成之后, 内存中的情景如下图所示:
而下面的代码是真真正正的clone了一个对象。
Person p = new Person(26, "hutao");
Person p1 = (Person) p.clone();
System.out.println(p);
System.out.println(p1);
//com.hutao.Person@2f9ee1ac
//com.hutao.Person@67f1fba0
3.2.深拷贝和浅拷贝
上面的示例代码中,Person 中有两个成员变量,分别是 name 和 age, name 是 String 类型, age 是 int 类型。代码非常简单,如下所示:
public class Person implements Cloneable{
private int age ;
private String name;
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public Person() {}
public int getAge() {
return age;
}
public String getName() {
return name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return (Person)super.clone();
}
}
由于 age 是基本数据类型,那么对它的拷贝没有什么疑议,直接将一个 4 字节的整数值拷贝过来就行。但是 name是 String 类型的, 它只是一个引用, 指向一个真正的 String 对象,那么对它的拷贝有两种方式:
- 直接将原对象中的 name 的引用值拷贝给新对象的 name 字段;
- 根据原 Person 对象中的 name 指向的字符串对象创建一个新的相同的字符串对象,将这个新字符串对象的引用赋给新拷贝的Person 对象的 name 字段。
这两种拷贝方式分别叫做浅拷贝和深拷贝。深拷贝和浅拷贝的原理如下图所示:
下面通过代码进行验证。如果两个 Person 对象的 name 的地址值相同, 说明两个对象的 name 都指向同一个String 对象,也就是浅拷贝, 而如果两个对象的 name 的地址值不同, 那么就说明指向不同的 String 对象, 也就是在拷贝 Person 对象的时候, 同时拷贝了 name 引用的 String 对象, 也就是深拷贝。验证代码如下:
Person p = new Person(23, "zhang");
Person p1 = (Person) p.clone();
String result = p.getName() == p1.getName() ? "clone 是浅拷贝的" : "clone 是深拷贝的";
System.out.println(result);
打印结果为
clone 是浅拷贝的
如何进行深拷贝?
如果想要深拷贝一个对象,这个对象必须要实现 Cloneable 接口,实现 clone方法,并且在 clone 方法内部,把该对象引用的其他对象也要 clone 一份,这就要求这个被引用的对象必须也要实现Cloneable 接口并且实现 clone 方法。那么,按照上面的结论,实现以下代码 Body 类组合了 Head 类,要想深拷贝Body 类,必须在 Body 类的 clone 方法中将 Head 类也要拷贝一份。代码如下:
static class Body implements Cloneable{
public Head head;
public Body() {}
public Body(Head head) {
this.head = head;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Body newBody = (Body) super.clone();
newBody.head = (Head) head.clone();
return newBody;
}
}
static class Head implements Cloneable{
public Face face;
public Head() {}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public static void main(String[] args) throws CloneNotSupportedException {
Body body = new Body(new Head(new Face()));
Body body1 = (Body) body.clone();
System.out.println("body == body1 : " + (body == body1) );
System.out.println("body.head == body1.head : " + (body.head == body1.head));
}
打印结果为:
body == body1 : false
body.head == body1.head : false