Java随笔 - 对象克隆

本文总结Java对象的浅复制和深复制，以及Clonable接口。

前言

对象在传递的时候，会进行对象复制。对象的复制，可以分为浅复制和深复制。

浅复制

在下面的例子中，可以实现对象的复制，origin和copy对象变量引用同一个内存区域，copy调用raiseSalary方法可以修改origin对象所引用的内容。

public class Employee {
    private double salary;
    
    {
        salary = 0.0;    
    }
    
    public double getSalary() {
        return this.salary;
    }
    
    public void raiseSalary(int t) {
        this.salary = salary * t;
    }
}

Employee origin = new Employee();
Employee copy = origin;
copy.raiseSalary(10);

在这次的复制过程中，实现的细节是：Object这个Java的万类祖先有个protect的clone方法，可以在相同类的对象上做拷贝。

但是，在整个复制的过程中，复制是有限制的，也就是不完全的，所以我们称之为浅复制，浅克隆，浅拷贝。Object这个超类在实现clone这个方法的时候，并不知道子孙类到底是什么，所以在复制的时候也就有了局限性，若需要复制的内容是数值或者其他基本类型，那没什么问题，直接复制即可；若是复制的内容是另一对象的引用呢？那clone复制的新内存区域仍然和原对象共享着一些信息。

浅复制有什么影响吗？我们来举两个例子。

• 例子1

      public class Employee {
          private String name;
          private double salary;

          {
              name = "";
              salary = 0.0;    
          }
    
          public double getSalary() {
              return this.salary;
          }
    
          public void raiseSalary(int t) {
              this.salary = salary * t;
          }
    
          //...
       }

        Employee origin = new Employee();
        Employee copy = origin;

在例子1中，我们在Employee中新增String类型的name变量，还是像之前的那样进行拷贝操作。拷贝之后，原对象和克隆对象的name指向了同一块区域，String是不可变的，也就是指向了常量池。

对于不可变对象的拷贝，其实是安全的，没什么影响，拷贝与否没什么影响，因为不管拷贝与否，不可变对象都是同一块内存，并不会因为拷贝了就另外分配一块内存。所以对于不可变对象，浅复制是安全的，可以安全的共享信息。

• 例子2

      public class Employee {
          private String name;
          private double salary;
          private Date hireDay;
      
          {
              name = "";
              salary = 0.0;    
          }
    
          public double getSalary() {
              return this.salary;
          }
    
          public void raiseSalary(int t) {
              this.salary = salary * t;
          }
    
          //...
      }

      Employee origin = new Employee();
      Employee copy = origin;

在新的例子中，我们新增了可变对象Date，这个时候不完全的拷贝，是有影响的。原本复制的用意是让克隆对象有单独的内存来管理自己的数据，但是由于浅复制导致原对象和克隆对象都指向了同一个可变的对象，那么任一对象进行修改，那就是灾难级别的，所以这时候我们需要深度复制。

深复制

通常，在复制对象的时候会考虑下面三个选项：

• 默认的clone方法是否能满足要求；
• 是否可以在可变的子对象上调用clone方法来修补默认的clone方法；
• 是不是不应该使用clone方法

对于第三个选项，其实是默认的，对于前两个选项，类必须：

• 实现Cloneable接口
• 重新定义clone方法，并制定为public访问修饰符

在Object类中制定了clone方法为protect，但是在新的Java语法规则中，已经变得宽松了，可以将clone方法重写成public的方法。

要建立深度复制来复制对象中另一个对象，那么就要实行Cloneable接口、重写clone方法，在clone方法里来完成这些复制，如下例子：

public class Employee implements Cloneable {
    private String name;
    private double salary;
    private Date hireDay;
    
    {
        name = "";
        salary = 0.0;    
    }
    
    public double getSalary() {
        return this.salary;
    }
    
    public void raiseSalary(int t) {
        this.salary = salary * t;
    }
    
    public Employee clone() throws CloneNotSupportedException {
        Employee cloned = (Employee)super.clone();
        cloned.hireDay = (Date)hireDay.clone();
    }
    
    ...
}

Employee origin = new Employee();
Employee copy = origin;

在新的clone实现里，指定了throws CloneNotSupportedException异常，其用意在于要实现Cloneable接口，否则就不支持深度拷贝，从而抛出异常。

在重写clone方法的时候，首先应该要调用超类的clone方法来完成浅复制，然后才去定制自己需要完成的深度复制。

在重写clone方法的时候，我们返回的类型是Employee，而不是原本自带的Object，与super类有别，这个是Java5后的特性，为clone指定正确的返回类型，这就是协变返回类型。

标记为Clone的类，在执行克隆方法的时候是内存二进制克隆，比new一个对象性能更好，但是直接在内存中拷贝，构造方法并不会被执行。