corajava--简单介绍java中的clone方法_cora java 什么意思-优快云博客

本文深入解析Java中的clone方法，区分浅拷贝与深拷贝，通过实例演示如何在自定义类中实现Cloneable接口，以达到对象的完整复制，避免因引用共享导致的数据意外更改。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考文档：

引言

clone方法是Object类中12个方法之一。如果想要自定义的类的对象实现复制（所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象，故clone的对象和源对象地址必然不相同），就需要实现Cloneable接口，并且覆盖其中的clone方法。

特点

clone有浅克隆和深克隆之分。如下Student所示：由于age是基本数据类型，那么对它的拷贝没有什么疑议，直接将一个4字节的整数值拷贝过来就行。但是name是String类型的，它只是一个引用，指向一个真正的String对象，那么对它的拷贝有两种方式：直接将源对象中的name的引用值拷贝给新对象的name字段，或者是根据原Person对象中的name指向的字符串对象创建一个新的相同的字符串对象，将这个新字符串对象的引用赋给新拷贝的Person对象的name字段。这两种拷贝方式分别叫做浅拷贝和深拷贝。为了更好的表达这个意思，我在Student类中定义一个Professor对象作为属性。

/**
 * 一个自定义的类需要被克隆，就需要实现Cloneable接口，实现其中的clone方法
 * 测试浅克隆
 */
public class Student implements Cloneable {
    private Integer age;
    private String name;
    private Professor professor;

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", professor=" + professor +
                '}';
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Professor getProfessor() {
        return professor;
    }

    public void setProfessor(Professor professor) {
        this.professor = professor;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}


public class Professor {
    private Integer age;
    private String name;

    @Override
    public String toString() {
        return "Professor{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

学生student1的导师为43岁的Professor Wang，恰好学生s2与学生s1同名同岁，但是s2的导师为45岁的Professor Liu，于是我们顺理成章地复制复制s1并复制给s2，再修改下s2的导师的信息。可是，问题出现了，当我们修改了s2的导师后（如下测试所示），s2的信息是对了，但是s1的导师信息也跟着修改了，这可不是我们期望的。

public class TestClone {

    /**
     * 测试浅克隆
     */
    @Test
    public void testClone1() {
        Professor professor = new Professor();
        professor.setAge(43);
        professor.setName("mr.wang");

        Student student1 = new Student();
        student1.setAge(21);
        student1.setName("song");
        student1.setProfessor(professor);

        try {
            Student student2 = (Student) student1.clone();
            Professor professor1 = student2.getProfessor();
            professor1.setName("mr.liu");
            professor1.setAge(45);
            student2.setProfessor(professor1);
            System.out.println("复制后的s1:" + student1);
            System.out.println("复制后的s2:" + student2);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

测试结果如下所示:

复制后的s1:Student{age=21, name='song', professor=Professor{age=45, name='mr.liu'}}
复制后的s2:Student{age=21, name='song', professor=Professor{age=45, name='mr.liu'}}

这就是浅拷贝。一般情况下，我们改变拷贝对象中的属性时，并需要改变源对象中的值，所以我们需要做到深拷贝。同样的我们让自定义对象中引用其他的对象也实现clone方法，并且做如下修改：

public class Professor implements Cloneable{
    private Integer age;
    private String name;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Professor{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Student implements Cloneable {
    private Integer age;
    private String name;
    private Professor professor;

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", professor=" + professor +
                '}';
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Professor getProfessor() {
        return professor;
    }

    public void setProfessor(Professor professor) {
        this.professor = professor;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student student = (Student) super.clone();
        student.professor = (Professor) professor.clone();
        return student;
    }
}

此时，再进行刚才的测试，就不会出现第一次测试时出现的问题了。

复制后的s1:Student{age=21, name='song', professor=Professor{age=43, name='mr.wang'}}
复制后的s2:Student{age=21, name='song', professor=Professor{age=45, name='mr.liu'}}

逗号

如果在拷贝一个对象时，要想让这个拷贝的对象和源对象完全彼此独立，那么在引用链上的每一级对象都要被显式的拷贝。所以创建彻底的深拷贝是非常麻烦的，尤其是在引用关系非常复杂的情况下，或者在引用链的某一级上引用了一个第三方的对象，而这个对象没有实现clone方法，那么在它之后的所有引用的对象都是被共享的，这也是浅拷贝和深拷贝的区别。之所以最后一部分称为逗号，因为本文没有介绍原型模式和clone的应用场景，在以后还会补充。