在Java中为什么不建议使用Object的clone()来拷贝对象

为什么不建议使用Object的clone()来拷贝对象

前言

最近阅读了《阿里巴巴Java开发手册》一书，书中提到了不推荐使用Object对象的clone()方法来对对象进行拷贝，因为Object的clone()方法默认是浅拷贝，原文如下：

【推荐】慎用Object的clone方法来拷贝对象。
说明：对象的clone方法默认是浅拷贝，若想实现深拷贝需要重写clone方法实现属性对象的拷贝。

浅拷贝与深拷贝

在Java中数据分为基本数据类型和引用数据类型，基本数据类型存储在栈中，而引用数据类型则是在栈中存储指向对象的引用地址，数据实际上存储在堆内存中。

浅拷贝只复制指向某个对象的地址，而不复制对象本身，新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。

clone()方法

java中的clone()方法在Object类中定义，如下图：

我们可以看到clone()方法使用protected访问修饰符修饰，所以我们可以在Object子类中重写这个方法并使用。

探究

以下实体类使用lombok生成构造器与get、set方法

首先我们创建一个员工类，重写并调用父类Object的clone()

/**
 * @package: com.vinci.testClone
 * @className: Employee
 * @author: Vinci
 * @description: 员工对象
 * @date: 2023/9/22 17:00
 */
@Data
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PUBLIC)
//注意，若使用clone(),要先实现Cloneable接口
public class Employee implements Cloneable{

    private int id;

    private String name;

    private int age;

    private double salary;

    private Company company;

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

}

不过需要注意，若使用clone(),要先实现Cloneable接口，否则会抛出CloneNotSupportedException异常

创建公司类，作为员工类的引用属性

/**
 * @package: com.vinci.testClone
 * @className: Company
 * @author: Vinci
 * @description:
 * @date: 2023/9/22 17:02
 */
@Data
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PUBLIC)
public class Company {

    private int id;

    private String name;

    private String address;

}

接着我们编写代码测试 clone（），创建一个员工对象，员工对象中包含公司对象

//使用有参构造器初始化对象
Employee employee = new Employee(
        1,"Vinci",23,10000D,
        new Company(
                1,
                "VinciOs",
                "波西米亚"
        )
);
// 输出结果 Employee(id=1, name=Vinci, age=23, salary=10000.0, company=Company(id=1, name=VinciOs, address=波西米亚))
System.out.println(employee);

使用 clone() 方法 拷贝对象

Employee newEmployee = (Employee) employee.clone();
//输出结果 Employee(id=1, name=Vinci, age=23, salary=10000.0, company=Company(id=1, name=VinciOs, address=波西米亚))
System.out.println(newEmployee);

我们可以看到两个对象的输出结果是一致的，那我们比较两个对象的地址呢？

 //比较两个对象的地址
 System.out.println(employee == newEmployee); // false
 //比较两个对象中引用数据类型的地址
 System.out.println(employee.getCompany() == newEmployee.getCompany());//ture

通过比较我们可以发现，两个对象的引用地址不相同，但是对象里包含的引用类型的地址却是相同的。

//如果我们要修改第二个员工的公司呢？
newEmployee.getCompany().setAddress("捷克");

//输出结果 Employee(id=1, name=Vinci, age=23, salary=10000.0, company=Company(id=1, name=VinciOs, address=捷克))
System.out.println(employee);
//输出结果 Employee(id=1, name=Vinci, age=23, salary=10000.0, company=Company(id=1, name=VinciOs, address=捷克))
System.out.println(newEmployee);

结果我们发现 由于这两个对象中的company属性引用的是同一个地址，因此不管修改哪一个另一个都会跟着改变，很容易出现事故
很多时候我们去拷贝对象是希望进行深度拷贝的，因此不建议使用clone()进行拷贝。

实现深度拷贝的两种方式

1、重写clone()方法

修改代码如下：

@Data
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PUBLIC)
//注意，若使用clone(),要先实现Cloneable接口
public class Employee implements Cloneable{

    private int id;

    private String name;

    private int age;

    private double salary;

    private Company company;

    @Override
    protected Object clone() throws CloneNotSupportedException {
//        return super.clone();
        Employee employee = (Employee) super.clone();
        employee.company = (Company) this.company.clone();
        return employee;
    }

}

@Data
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PUBLIC)
public class Company implements Cloneable{

    private int id;

    private String name;

    private String address;

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


}

随后我们再运行同样的代码，发现：

2、使用序列化实现深度拷贝

需要导入依赖,并将两个类实现Serializable接口

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

 public void serializedCopy(){
      //创建对象
      Employee employee = new Employee(
              1,"Vinci",23,10000D,
              new Company(
                      1,
                      "VinciOs",
                      "波西米亚"
              )
      );
      //序列化对象
      byte[] serialize = SerializationUtils.serialize(employee);
      //反序列化对象
      Employee newEmployee = SerializationUtils.deserialize(serialize);
      System.out.println(newEmployee == employee); // false
}

测试后我们发现，使用序列化实现的拷贝，完全是全新的对象，是深度拷贝的。