深克隆與淺克隆的區別

1.實現克隆的方式

1.對象的類需要實現Cloneable接口

2.重寫Object類中的clone()方法

3.根據重寫的clone()方法得到想要的克隆結果，例如淺克隆與深克隆。

2.深克隆與淺克隆的區別

圖解：

代碼：

淺克隆：

//學生類
public class Student implements Cloneable{
    private String name;
    private Integer age;
    private Grade grade;

    public Student(String name, Integer age, Grade grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                '}';
    }
    @Override
    protected Student clone() throws CloneNotSupportedException {
       return (Student) super.clone();
    }
}

//成績類
public class Grade {
    private Integer chinese;
    private Integer math;
    private Integer english;

    public Grade(Integer chinese, Integer math, Integer english) {
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }

    public Integer getChinese() {
        return chinese;
    }

    public void setChinese(Integer chinese) {
        this.chinese = chinese;
    }

    public Integer getMath() {
        return math;
    }

    public void setMath(Integer math) {
        this.math = math;
    }

    public Integer getEnglish() {
        return english;
    }

    public void setEnglish(Integer english) {
        this.english = english;
    }

    @Override
    public String toString() {
        return "Grade{" +
                "chinese=" + chinese +
                ", math=" + math +
                ", english=" + english +
                '}';
    }
      @Override
    protected Grade clone() throws CloneNotSupportedException {
       return (Grade)super.clone();
    }
}

//測試類
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student = new Student("student", 18, new Grade(100, 100, 100));
        Student newStudent = (Student) student.clone();
        newStudent.setName("newStudent");
        newStudent.setAge(20);
        newStudent.getGrade().setChinese(90);
        newStudent.getGrade().setEnglish(90);
        newStudent.getGrade().setMath(90);
        System.out.println(student);
        System.out.println(newStudent);
    }
}

//測試結果
Student{name='student', age=18, grade=Grade{chinese=90, math=90, english=90}}
Student{name='newStudent', age=20, grade=Grade{chinese=90, math=90, english=90}}

結論：淺克隆只克隆基本數據屬性，不會克隆對象屬性引用的對象（也就是不會克隆Student對象引用的Grade對象），克隆前后兩個對象的引用指向同一個對象。

深克隆：

//學生類
  @Override
    protected Student clone() throws CloneNotSupportedException {
        Student newStudent = (Student) super.clone();
        Grade grade = (Grade) newStudent.getGrade().clone();
        newStudent.setGrade(grade);
        return newStudent;
    }

//測試結果
Student{name='student', age=18, grade=Grade{chinese=100, math=100, english=100}}
Student{name='newStudent', age=20, grade=Grade{chinese=90, math=90, english=90}}

結論：深克隆不僅克隆基本數據屬性，還會克隆對象屬性引用的對象（在Student類的clone()方法中再克隆一次Grade對象）