Java基础|对象克隆深浅拷贝你真的搞懂了吗？

1 什么时候需要 clone

如果希望 copy 是一个新对象，它的初始状态与 origin 相同，但之后它们各自会有自己不同的状态，这种情况下使用 clone 方法。

2 从访问规则微妙的 protected 说起

当子类和超类在不同的包中时，protected 修饰的字段，方法被访问的规则比较微妙（搞明白这一点为重写 clone 方法做铺垫）。

类的实例对象所在的包	对 protected 修饰的字段，方法访问情况
子类和超类实例对象和超类同一个包	子类实例可访问超类的 protected 域和方法；子类实例无法访问自己的 protected 域和方法；超类实例当然可以访问自己的 protected 域和方法。
子类和超类实例对象和子类同一个包	子类实例无法访问超类的 protected 域和方法；子类实例可访问自己的 protected 域和方法；超类实例无法访问自己的 protected 域和方法。
子类和超类实例对象不在父类和子类包中	子类实例无法访问超类和自己的 protected 域和方法；超类实例无法访问自己的 protected 域和方法。

3 浅拷贝

clone 方法是 Object 的一个 protected 方法，所以说你的代码不能直接调用这个方法（上面已经分析的很清楚了，所有类都是 Object 的子类，其实例对象不会和 Object 在同一个包）。如果对象中的所有数据域都是数值或是其他基本数据类型，拷贝这些域没有问题；如果包含对象引用，拷贝域就会得到对应对象的另一个引用。对象引用这一部分是共享的，其它引用对其修改会引起改变。

4 深拷贝

（1）深拷贝说明

如果能确保浅拷贝的情况下，共享的那一部分数据（引用的对象）始终是不可变的，如共享的是 String 对象（不可变对象），LocalDate 对象（不可变对象），那么这种情况下就是深拷贝。

（2）建立深拷贝步骤

• 判定默认 clone 方法不能满足要求；
• 类重写 clone 方法时要实现 Cloneable 接口（Cloneable只是一个标记作用，在类型查询时可用 instanceof）；
• 重新定义clone方法，并指定修饰符为public。

（3）说明

在一个对象上调用clone方法时，如果这个对象的类没有实现Cloneable接口，就会抛出 CloneNotSupportedException。所有的数组都有一个public的clone 方法。

5 代码示例

Employee类

import java.util.Date;
import java.util.GregorianCalendar;

/**
 * @version $Id: Employee.java, v 0.1 2017年6月15日 上午10:50:17
 */
public class Employee implements Cloneable {
    private String name;
    private double salary;
    private Date   hireDay;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
        hireDay = new Date();
    }

    public Employee clone() throws CloneNotSupportedException {
        //调用Object的clone()
        Employee cloned = (Employee) super.clone();
        //克隆可变的字段
        cloned.hireDay = (Date) hireDay.clone();
        return cloned;
    }

    public void setHireDay(int year, int month, int day) {
        //GregorianCalendar()生成阳历的一个时间类
        Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();
        hireDay.setTime(newHireDay.getTime());
    }

    public void raiseSalary(double byPercent) {
        double raise = salary * byPercent / 100;
        salary += raise;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", salary=" + salary + ", hireDay=" + hireDay + "]";
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Date getHireDay() {
        return hireDay;
    }

    public void setHireDay(Date hireDay) {
        this.hireDay = hireDay;
    }
}

测试代码

/**
 * 
 * @version $Id: CloneTest.java, v 0.1 2017年6月17日 下午1:12:41
 */
public class CloneTest {
    public static void main(String[] args) {
        try {
            Employee original = new Employee("Ori-emp", 5000);
            Employee copy = original.clone();
            System.out.println("最初状态：");
            System.out.println(original.toString());
            System.out.println(copy.toString());

            System.out.println("各自更改自己的状态：");
            original.raiseSalary(10);
            original.setHireDay(2017, 6, 16);
            copy.raiseSalary(20);
            copy.setHireDay(2012, 12, 31);
            System.out.println(original.toString());
            System.out.println(copy.toString());
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
    }
}

测试结果：

最初状态：
Employee [name=Ori-emp, salary=5000.0, hireDay=Sat Jun 17 13:23:31 CST 2017]
Employee [name=Ori-emp, salary=5000.0, hireDay=Sat Jun 17 13:23:31 CST 2017]
各自更改自己的状态：
Employee [name=Ori-emp, salary=5500.0, hireDay=Fri Jun 16 00:00:00 CST 2017]
Employee [name=Ori-emp, salary=6000.0, hireDay=Mon Dec 31 00:00:00 CST 2012]