java浅拷贝与深拷贝

一、拷贝的类型

        当需要了解拷贝（copy）的时候，我们需要先明白拷贝的类型。初学者可能会不太理解，拷贝也区分类型？

        假如是简单的对象复用，其实也称之为拷贝，例如，新建一个对象A，然后令B = A，此时即拷贝了A。但是这种方式，A的内存地址是否等于B？B是否称为新对象？是否A和B的属性在修改后会不一致呢？当思考到这些问题的时候，大家可能就需要去认识拷贝的类型了，以及浅拷贝、深拷贝!

1、引用拷贝

        引用拷贝是最简单的拷贝，即B = A。如下：

1）建立一个Teacher类：

package copy.entity;

public class Teacher {
    private String name;
    private int 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;
    }

}

2）代码测试引用拷贝：

package copy;

import copy.entity.Teacher;

public class TestCopy {

    public static void main(String[] args) {
        Teacher teacher1 = new Teacher();
        Teacher teacher2 = teacher1;
        teacher1.setAge(19);
        System.out.println(teacher1);
        System.out.println(teacher2);
    }

}

输出结果：

从输出结果看，未重写toString的情况下，打印对象地址值相同，也意味着这是同一个对象。teacher1和teacher2通过引用关系（内存中的栈区），实际上，最终都指向了一个对象（内存中的堆区），只是引用名称不同，这种称之为引用拷贝。

2、对象拷贝

        而对象拷贝，从上面分析大家可以推断出，必定会在堆内存中，产生一个新对象。

        对象拷贝的实现，需要对象类实现一个拷贝接口Cloneable，并重写其clone()方法：

1）改写Teacher类：

package copy.entity;

public class Teacher implements Cloneable{
    private String name;
    private int 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
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

2）测试代码：

package copy;

import copy.entity.Teacher;

public class TestCopy {

    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher1 = new Teacher();
        teacher1.setAge(19);
        teacher1.setName("流川枫");
        Teacher teacher2 = (Teacher)teacher1.clone();
        System.out.println(teacher1);
        System.out.println(teacher2);
    }

}

测试结果：

测试结果中看出，此时的对象地址值已经不一致，这个情况就是对象拷贝。

二、浅拷贝与深拷贝

        浅拷贝与深拷贝，都属于对象拷贝。处于对象拷贝类型下。主要区别在于，假如产生对象引用其他对象时，这个第三方被引用的对象是否因为拷贝产生变化！

        · 对象拷贝中，深浅拷贝地址值都是不同；

        · 对象拷贝中，深浅拷贝的属性皆不同；

        · 对象拷贝中，浅拷贝对象，指向第三方对象时，第三方对象不变。深拷贝相反。例子举证：

1、浅拷贝：与上述的对象拷贝例子差不多，但是为了区分深拷贝，所以加点内容

1）Teacher类，实现Cloneable接口，重写clone()，作为被引用指向的第三方对象，重写下toString，用于比较引用第三方对象区别：

package copy.entity;

public class Teacher implements Cloneable{
    private String name;
    private int 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
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

2）Student类，实现Cloneable接口，重写clone()，重写下toString，用于比较引用第三方对象区别：

package copy.entity;

public class Student implements Cloneable{
    private String name;
    private int age;
    private Teacher teacher;

    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 Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

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

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

代码测试：

package copy;

import copy.entity.Student;
import copy.entity.Teacher;

public class TestCopy {

    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher1 = new Teacher();
        teacher1.setAge(45);
        teacher1.setName("三木长一郎");
        System.out.println(teacher1);

        Student student1 = new Student();
        student1.setAge(15);
        student1.setName("樱木花道");
        student1.setTeacher(teacher1);


        Student studeng2 = (Student)student1.clone();
        studeng2.setName("古美门研介");
        studeng2.setAge(30);

        teacher1.setName("安西");
        System.out.println("student1："+student1);
        System.out.println("studnet2："+studeng2);
    }

}

简单分析下上述代码：

· 新建teacher1，属性复制“三木长一郎”；

· 新建student1，属性引用对象teacher1；

· 克隆student2，修改其非引用类型，在克隆中，这个修改后是不一致的；

· 修改teacher1的name属性，变更为“安西”，此时有先后顺序，先克隆再修改；

        结果 -- 看到2个students普通属性不一致了，但是指向的引用对象，却依旧一致，指向最新对象了。这就是浅拷贝！

        反之，深拷贝的简单理解，会导致指向的对象，实际也是不同。

2、深拷贝：

1）代码按照浅拷贝的基础，只需要改动student类下的clone()重写内容：

    @Override
    public Object clone() throws CloneNotSupportedException {
        //深拷贝的区别点：
        Student student = (Student)super.clone();
        student.setTeacher((Teacher)student.getTeacher().clone());
        return student;
    }

2）测试结果：

如图，看过灌篮高手和legal high的同学应该清楚，有什么产生了变化对吧~~