浅拷贝

基本概念

如果属性是基本类型，拷贝的就是基本类型的值；如果属性是引用类型，拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。

代码实现

实现对象拷贝的类，需要实现 Cloneable 接口，并覆写 clone() 方法。

  1. public class Student implements Cloneable {
  3.     //引用类型
  4.     private Subject subject;
  5.     //基础数据类型
  6.     private String name;
  7.     private int age;
  9.     public Subject getSubject() {
  10.         return subject;
  11.     }
  13.     public void setSubject(Subject subject) {
  14.         this.subject = subject;
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public int getAge() {
  26.         return age;
  27.     }
  29.     public void setAge(int age) {
  30.         this.age = age;
  31.     }
  33.     /**
  34.      *  重写clone()方法
  35.      * @return
  36.      */
  37.     @Override
  38.     public Object clone() {
  39.         //浅拷贝
  40.         try {
  41.             // 直接调用父类的clone()方法
  42.             return super.clone();
  43.         } catch (CloneNotSupportedException e) {
  44.             return null;
  45.         }
  46.     }
  48.     @Override
  49.     public String toString() {
  50.         return "[Student: " + this.hashCode() + ",subject:" + subject + 
  51.             ",name:" + name + ",age:" + age + "]";
  52.     }
  53. }

浅拷贝和对象拷贝的区别

Student studentB = (Student) studentA.clone() 换成了 Student studentB = studentA
对象拷贝后没有生成新的对象，二者的对象地址是一样的；而浅拷贝的对象地址是不一样的。

深拷贝

基本概念

  1. 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）。
  2. 对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。

  3. 对于有多层对象的，每个对象都需要实现 Cloneable 并重写 clone() 方法，进而实现了对象的串行层层拷贝。

    代码实现

    1. public class Subject implements Cloneable {
    3.  private String name;
    5.  public Subject(String name) {
    6.      this.name = name;
    7.  }
    9.  public String getName() {
    10.      return name;
    11.  }
    13.  public void setName(String name) {
    14.      this.name = name;
    15.  }
    17.  @Override
    18.  protected Object clone() throws CloneNotSupportedException {
    19.      //Subject 如果也有引用类型的成员属性，也应该和 Student 类一样实现
    20.      return super.clone();
    21.  }
    23.  @Override
    24.  public String toString() {
    25.      return "[Subject: " + this.hashCode() + ",name:" + name + "]";
    26.  }
    27. }
    1. public class Student implements Cloneable {
    3.  //引用类型
    4.  private Subject subject;
    5.  //基础数据类型
    6.  private String name;
    7.  private int age;
    9.  public Subject getSubject() {
    10.      return subject;
    11.  }
    13.  public void setSubject(Subject subject) {
    14.      this.subject = subject;
    15.  }
    17.  public String getName() {
    18.      return name;
    19.  }
    21.  public void setName(String name) {
    22.      this.name = name;
    23.  }
    25.  public int getAge() {
    26.      return age;
    27.  }
    29.  public void setAge(int age) {
    30.      this.age = age;
    31.  }
    33. /**
    34.   *  重写clone()方法
    35.   * @return
    36.   */
    37.  @Override
    38.  public Object clone() {
    39.      //深拷贝
    40.      try {
    41.          // 直接调用父类的clone()方法
    42.          Student student = (Student) super.clone();
    43.          //调用subject的clone()方法
    44.          student.subject = (Subject) subject.clone();
    45.          return student;
    46.      } catch (CloneNotSupportedException e) {
    47.          return null;
    48.      }
    49.  }
    51.  @Override
    52.  public String toString() {
    53.      return "[Student: " + this.hashCode() + ",subject:" + subject + ",name:" + name + ",age:" + age + "]";
    54.  }
    55. }