深拷贝和浅拷贝到底有什么区别？

1. Object clone()

在Java语言中，所有对象的父类Object有一个clone()方法，但是new出来的对象不能调用它。如何来让对象可以调用该方法呢？ 答案是重写Object的clone()方法并实现Cloneable接口。

public class Student implements Cloneable{
    private String name;
    private int age;
    private Cat cat;

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

   	……省略属性的getter、setter方法
}

按照上面的方法实现的类已经可以调用clone()，接下来我们就可以探究深拷贝和浅拷贝的区别了。

浅拷贝

浅拷贝简单来说，浅拷贝相对于new了一个新的，新对象和旧对象的非引用数据类型的属性值相同，两者这类属性的修改互不影响。但是新对象和旧对象的引用类型属性引用地址是相同的，相对于对于引用类型复制了地址，实际上，引用的还是同一个对象，修改引用类型的属性值另一个对象也会改变。
下面是一个student类，有三个属性，两个非引用类型，一个cat属性为引用类型。

public class Student implements Cloneable{
    private String name;
    private int age;
    private Cat cat;

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

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

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

public class Cat {

    private String name;

    private int age;

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


    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

public static void main(String[] args) throws CloneNotSupportedException {
        Student student = new Student("xiaoming", 17);
        Cat cat = new Cat("huahua", 6);
        student.setCat(cat);
        Student studentC = (Student)student.clone();

        System.out.println(studentC == student); // false
        System.out.println(studentC.getCat() == student.getCat()); // true
}

上述代码执行的结果为false和true，第二个结果为true，说明这两个对象的cat属性地址是相同的，这就是浅拷贝。

深拷贝

深拷贝其实是浅拷贝的完善，要实现深拷贝要求对象进行clone时，对于引用类型对象，调用其自身的clone方法进行克隆，这样拷贝出来的对象，就是完全不同的对象，两者不会相互影响。

下面的代码中，Person有三个属性，其中Dog为引用类型，person和dog都实现了Cloneable接口并重写了clone方法，注意，person中的clone方法中调用了dog的clone方法。

public class Person implements Cloneable{
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person clone = (Person) super.clone();
        clone.dog = (Dog) dog.clone();
        return clone;
    }

    private String name;

    private int age;

    private Dog dog;

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

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


    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

public class Dog implements Cloneable{

    private String name;

    private int age;

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


    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person("yewenjie", 40);
        Dog dog = new Dog("panghu", 2);
        person.setDog(dog);
        Person personC = (Person) person.clone();
        System.out.println(person == personC); //false
        System.out.println(person.getDog() == personC.getDog()); // false
}

从上面的代码测试结果来看，拷贝出来的对象与被拷贝对象是完全不同的对象，这样就实现了深拷贝。

总结

浅拷贝只是拷贝了引用类型属性的地址，而深拷贝拷贝了引用类型属性的数据，实现了完全拷贝。