clone 对象的使用

复制对象和复制引用的区别

当 Person p1 = p;执行之后， 是创建了一个新的对象吗? 首先看打印结果:

可以看出，打印的地址值是相同的，既然地址都是相同的，那么肯定是同一个对象。p 和 p1 只是引用而已，他们 都指向了一个相同的对象 Person(23, “zhang”) 。 可以把这种现象叫做引用的复制。上面代码执行完成之后， 内 存中的情景如下图所示:

1. Person p = new Person(23, "zhang"); 2. Person p1 = p;
3. System.out.println(p);
4. System.out.println(p1);

 

1.com.itheima.Person@2f9ee1ac

2.com.itheima.Person@2f9ee1ac

 

而下面的代码是真真正正的克隆了一个对象。

 

1.Person p = new Person(23, "zhang");

2.Person p1 = (Person) p.clone();

3.System.out.println(p);

4.System.out.println(p1);

从打印结果可以看出，两个对象的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个 新的引用变量:

以上代码执行完成后， 内存中的情景如下图所示:

深拷贝和浅拷贝

上面的示例代码中，Person 中有两个成员变量，分别是 name 和 age， name 是 String 类型， age 是 int 类 型。代码非常简单，如下所示:

public class Person implements Cloneable{ 
    privatint 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 是浅拷贝的
所以，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));
}

打印结果为:

1. body == body1 : false
2. body.head == body1.head : false