为什么不建议使用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.commonsgroupId>
<artifactId>commons-lang3artifactId>
<version>3.12.0version>
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
}
测试后我们发现，使用序列化实现的拷贝，完全是全新的对象，是深度拷贝的。