如何使用Java实现拷贝构造 Java复制对象的实现技巧-小浪学习网

Java中实现对象拷贝主要有三种方式，分别适用于不同场景。1. 使用clone()方法：通过实现cloneable接口并重写clone()方法，可实现浅拷贝，默认复制字段值，引用类型仅复制引用地址；若需深拷贝，需手动对引用字段递归克隆。2. 使用拷贝构造器：定义接受同类型对象的构造方法，通过复制字段值实现拷贝，更符合面向对象设计，类型安全且易于控制深浅拷贝。3. 使用序列化实现深拷贝：适用于复杂对象图，通过对象流将对象写入并读取，生成独立副本，所有相关类需实现serializable接口。浅拷贝仅复制字段值与引用地址，深拷贝则递归复制引用对象，确保新旧对象完全独立。在实际开发中，拷贝构造器因类型安全、无异常处理、支持final字段等优点，通常优于clone()方法。常见应用场景包括数据传输对象（dto）的隔离、不可变对象的“修改”、撤销/重做功能实现等。

如何使用Java实现拷贝构造 Java复制对象的实现技巧

Java中实现对象拷贝，说白了，就是如何创建一个现有对象的独立副本。这事儿听起来简单，但背后其实涉及到浅拷贝和深拷贝两大概念。核心的实现技巧无外乎几种：最直接的是实现Cloneable接口并重写clone()方法，或者更推荐的做法是自定义一个“拷贝构造器”，再或者，对于复杂场景，利用序列化机制也能达到深拷贝的目的。选择哪种方式，真得看你对“复制”的深度需求，是只要个壳子，还是连同壳子里的所有东西都一并复制一份。

如何使用Java实现拷贝构造 Java复制对象的实现技巧

解决方案

在Java里，对象拷贝这事儿，从本质上讲，就是创建现有对象的一个新实例，并将原实例的状态（字段值）复制到新实例中。但这个“复制”的深度，决定了是浅拷贝还是深拷贝。

1. 使用clone()方法（实现Cloneable接口）

立即学习“Java免费学习笔记（深入）”；

如何使用Java实现拷贝构造 Java复制对象的实现技巧

这是Java提供的一种标准（但有时也受争议）的对象复制方式。

原理： Object类中有一个受保护的clone()方法，它执行的是字段值的复制。如果字段是基本类型，则复制其值；如果字段是对象引用，则复制其引用，而不是引用指向的对象本身（这就是浅拷贝）。
实现：
1. 你的类必须实现Cloneable接口（一个标记接口，没有方法）。
2. 重写Object类的clone()方法，并将其可见性改为public。
3. 在重写的clone()方法中，通常先调用super.clone()。
4. 如果需要深拷贝，对于引用类型的字段，你还需要手动地对它们进行递归克隆。

class Address implements Cloneable {     String city;     String street;      public Address(String city, String street) {         this.city = city;         this.street = street;     }      @Override     public String toString() {         return "Address{" + "city='" + city + ''' + ", street='" + street + ''' + '}';     }      @Override     protected Object clone() throws CloneNotSupportedException {         return super.clone(); // 浅拷贝     } }  class Person implements Cloneable {     String name;     int age;     Address address; // 引用类型字段      public Person(String name, int age, Address address) {         this.name = name;         this.age = age;         this.address = address;     }      @Override     public String toString() {         return "Person{" + "name='" + name + ''' + ", age=" + age + ", address=" + address + '}';     }      // 浅拷贝实现     public Person shallowClone() throws CloneNotSupportedException {         return (Person) super.clone();     }      // 深拷贝实现     public Person deepClone() throws CloneNotSupportedException {         Person clonedPerson = (Person) super.clone();         // 对引用类型字段进行深拷贝         if (this.address != null) {             clonedPerson.address = (Address) this.address.clone();         }         return clonedPerson;     } }  // 示例用法 public class CloneExample {     public static void main(String[] args) throws CloneNotSupportedException {         Address originalAddress = new Address("Beijing", "Chaoyang");         Person originalPerson = new Person("Alice", 30, originalAddress);          // 浅拷贝         Person shallowCopiedPerson = originalPerson.shallowClone();         System.out.println("Original: " + originalPerson);         System.out.println("Shallow copy: " + shallowCopiedPerson);          // 修改浅拷贝对象的地址，会影响原对象         shallowCopiedPerson.address.city = "Shanghai";         System.out.println("After shallow copy modify:");         System.out.println("Original: " + originalPerson);         System.out.println("Shallow Copy: " + shallowCopiedPerson);         System.out.println("--------------------");          // 深拷贝         Address anotherAddress = new Address("Guangzhou", "Tianhe");         Person anotherPerson = new Person("Bob", 25, anotherAddress);         Person deepCopiedPerson = anotherPerson.deepClone();         System.out.println("Original (deep): " + anotherPerson);         System.out.println("Deep Copy (deep): " + deepCopiedPerson);          // 修改深拷贝对象的地址，不会影响原对象         deepCopiedPerson.address.city = "Shenzhen";         System.out.println("After deep copy modify:");         System.out.println("Original (deep): " + anotherPerson);         System.out.println("Deep Copy (deep): " + deepCopiedPerson);     } }

2. 使用拷贝构造器（Copy constructor）

如何使用Java实现拷贝构造 Java复制对象的实现技巧

这是我个人更倾向于的一种方式，因为它更符合面向对象的设计原则，也更清晰、类型安全。

原理： 定义一个构造方法，它接受一个同类型的对象作为参数，并在构造过程中将参数对象的字段值复制到新创建的实例中。
实现：

class Department {     String name;      public Department(String name) {         this.name = name;     }      // 拷贝构造器 (浅拷贝)     public Department(Department other) {         this.name = other.name;     }      @Override     public String toString() {         return "Department{" + "name='" + name + ''' + '}';     } }  class Employee {     String employeeId;     String employeeName;     Department department; // 引用类型字段      public Employee(String employeeId, String employeeName, Department department) {         this.employeeId = employeeId;         this.employeeName = employeeName;         this.department = department;     }      // 拷贝构造器 (浅拷贝)     public Employee(Employee other) {         this.employeeId = other.employeeId;         this.employeeName = other.employeeName;         this.department = other.department; // 仅仅复制引用     }      // 拷贝构造器 (深拷贝)     public Employee(Employee other, Boolean deepCopy) {         this.employeeId = other.employeeId;         this.employeeName = other.employeeName;         if (deepCopy && other.department != null) {             this.department = new Department(other.department); // 对引用类型字段进行深拷贝         } else {             this.department = other.department; // 浅拷贝         }     }      @Override     public String toString() {         return "Employee{" + "employeeId='" + employeeId + ''' + ", employeeName='" + employeeName + ''' + ", department=" + department + '}';     } }  // 示例用法 public class CopyConstructorExample {     public static void main(String[] args) {         Department hrDept = new Department("HR");         Employee originalEmployee = new Employee("E001", "John Doe", hrDept);          // 使用浅拷贝构造器         Employee shallowCopiedEmployee = new Employee(originalEmployee);         System.out.println("Original: " + originalEmployee);         System.out.println("Shallow Copy: " + shallowCopiedEmployee);          // 修改浅拷贝对象的部门名称，会影响原对象         shallowCopiedEmployee.department.name = "Finance";         System.out.println("After shallow copy modify:");         System.out.println("Original: " + originalEmployee);         System.out.println("Shallow Copy: " + shallowCopiedEmployee);         System.out.println("--------------------");          // 使用深拷贝构造器         Department salesDept = new Department("Sales");         Employee anotherOriginal = new Employee("E002", "Jane Smith", salesDept);         Employee deepCopiedEmployee = new Employee(anotherOriginal, true); // 传入true表示深拷贝         System.out.println("Original (deep): " + anotherOriginal);         System.out.println("Deep Copy (deep): " + deepCopiedEmployee);          // 修改深拷贝对象的部门名称，不会影响原对象         deepCopiedEmployee.department.name = "Marketing";         System.out.println("After deep copy modify:");         System.out.println("Original (deep): " + anotherOriginal);         System.out.println("Deep Copy (deep): " + deepCopiedEmployee);     } }

3. 使用序列化（Serialization）实现深拷贝

这是一种非常强大的实现深拷贝的技巧，尤其适用于对象图非常复杂的情况。

原理： 将对象写入一个输出流（例如ByteArrayOutputStream），然后从该流中读取回来，这样就创建了一个全新的对象图。
实现：
1. 所有需要被序列化的类（包括其所有引用类型的字段）都必须实现Serializable接口。
2. 使用ObjectOutputStream将对象写入字节数组。
3. 使用ObjectInputStream从字节数组中读取对象。

import java.io.*;  class Company implements Serializable {     String name;     String address;      public Company(String name, String address) {         this.name = name;         this.address = address;     }      @Override     public String toString() {         return "Company{" + "name='" + name + ''' + ", address='" + address + ''' + '}';     } }  class Product implements Serializable {     String productId;     String productName;     Company manufacturer; // 引用类型字段      public Product(String productId, String productName, Company manufacturer) {         this.productId = productId;         this.productName = productName;         this.manufacturer = manufacturer;     }      @Override     public String toString() {         return "Product{" + "productId='" + productId + ''' + ", productName='" + productName + ''' + ", manufacturer=" + manufacturer + '}';     } }  public class SerializationDeepCopy {      public static <T extends Serializable> T deepCopy(T obj) {         try {             ByteArrayOutputStream bos = new ByteArrayOutputStream();             ObjectOutputStream oos = new ObjectOutputStream(bos);             oos.writeObject(obj);             oos.flush();             oos.close();             bos.close();              ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());             ObjectInputStream ois = new ObjectInputStream(bis);             T copiedObj = (T) ois.readObject();             ois.close();             bis.close();             return copiedObj;         } catch (IOException | ClassNotFoundException e) {             e.printStackTrace();             return null;         }     }      public static void main(String[] args) {         Company originalCompany = new Company("TechCorp", "Silicon Valley");         Product originalProduct = new Product("P101", "Smartphone", originalCompany);          Product deepCopiedProduct = deepCopy(originalProduct);          System.out.println("Original: " + originalProduct);         System.out.println("Deep Copy: " + deepCopiedProduct);          // 修改深拷贝对象的制造商名称，不会影响原对象         if (deepCopiedProduct != null) {             deepCopiedProduct.manufacturer.name = "GlobalTech";             System.out.println("After deep copy modify:");             System.out.println("Original: " + originalProduct);             System.out.println("Deep Copy: " + deepCopiedProduct);         }     } }

Java中浅拷贝与深拷贝的本质区别是什么？

浅拷贝和深拷贝，这俩概念是理解Java对象复制的关键。说白了，它们决定了复制的“深度”。

浅拷贝（Shallow Copy） 当你执行浅拷贝时，系统会为新对象分配一块内存，然后将原对象的所有字段值复制到新对象中。

基本数据类型（如int, double, boolean等）： 直接复制其值。所以，原对象和新对象的这些字段是完全独立的，修改其中一个不会影响另一个。
引用数据类型（如自定义对象、数组、集合等）： 仅仅复制其引用地址，而不是引用指向的对象本身。这意味着，原对象和新对象的这个引用字段都指向内存中的同一个对象。如果通过新对象修改了这个共享的引用对象，那么原对象也会“看到”这些修改，反之亦然。你可以想象成两个人手里拿着同一把钥匙，这把钥匙能打开同一个房间。

深拷贝（Deep Copy） 深拷贝则要彻底得多。它不仅复制了原对象的所有字段值，如果这些字段是引用类型，它还会递归地创建这些引用指向的对象的独立副本。

基本数据类型： 和浅拷贝一样，直接复制值。
引用数据类型： 会创建一个全新的对象，并将原引用对象的内容复制到这个新对象中。这样，原对象和新对象各自拥有独立的引用对象，它们之间没有任何关联。修改其中一个，绝不会影响到另一个。就像两个人各自拥有一套完全独立的房子和钥匙，互不干扰。

简而言之，浅拷贝只复制了“表面”，而深拷贝则复制了“里里外外”所有层级。在实际开发中，如果你的对象内部包含可变（mutable）的引用类型字段，并且你不希望拷贝对象修改后影响到原对象，那么深拷贝就是你必须考虑的。否则，浅拷贝可能导致一些难以追踪的副作用。

什么时候应该选择拷贝构造器而非clone()方法？

这问题问得好，因为在Java里，clone()方法一直是个有点争议的存在。在我看来，大多数时候，我个人会更倾向于使用拷贝构造器，而不是clone()。

clone()方法的“槽点”：

Cloneable接口是个标记接口： 它没有任何方法，仅仅是告诉jvm，这个类的实例可以被克隆。但真正的clone()方法是在Object类中定义的，而且它是protected的。这意味着你必须在自己的类中重写它，并将其可见性改为public才能外部调用。这有点反直觉。
强制类型转换和异常： Object.clone()返回的是Object类型，所以你每次调用后都必须进行强制类型转换。同时，它会抛出CloneNotSupportedException这个受检异常，即使你的类实现了Cloneable，也可能因为父类没有正确实现clone()而抛出，这增加了代码的冗余和复杂性。
默认是浅拷贝： 这是最大的问题。如果你有引用类型的字段，clone()默认只复制引用，而不是引用指向的对象。要实现深拷贝，你必须手动在clone()方法内部对所有引用字段进行递归克隆，这会变得非常繁琐，尤其当对象图很复杂时。
打破封装性： clone()方法需要访问对象的内部状态才能进行复制。这在某种程度上打破了封装原则，因为它需要了解对象的内部结构。
继承链中的复杂性： 在复杂的继承体系中，正确实现clone()会变得非常棘手。每个父类都可能需要正确实现clone()，否则子类的clone()行为可能不符合预期。

拷贝构造器的优势：

类型安全，无需强制转换： 拷贝构造器直接返回你想要的类型，不需要额外的类型转换，代码更清晰。
没有受检异常： 它就是一个普通的构造器，不会抛出CloneNotSupportedException，代码更简洁。
更明确的控制深浅拷贝： 你可以在拷贝构造器内部明确地控制每个字段的复制逻辑。对于引用类型，你可以选择是复制引用（浅拷贝），还是创建新实例（深拷贝），一目了然。
符合封装原则： 拷贝构造器通常通过公共的getter方法或直接访问字段（如果类内部允许）来获取原对象的状态，这更符合面向对象的设计原则。
支持final字段： clone()方法不能为final字段赋值（因为final字段只能在构造器中初始化），而拷贝构造器可以。

总结： 虽然clone()是Java提供的内置机制，但在大多数现代Java开发中，由于其固有的设计缺陷和使用上的不便，拷贝构造器或序列化（用于深拷贝）通常是更推荐的选择。拷贝构造器提供了更好的类型安全性、可读性、可维护性和对复制过程的精确控制。

Java对象拷贝在实际项目中有哪些常见应用场景？

Java对象拷贝这事儿，可不是个摆设，在实际项目里用得还挺多的，尤其是在处理数据流转、状态管理和并发编程的时候。

数据传输对象（DTO）/值对象（Value Object）的隔离： 想象一下，你的服务层从数据库取出了一个User对象，然后要把它传递给Web层展示。如果直接把这个User对象传过去，Web层可能会无意中修改了User对象的某个属性，而这个修改又“反向”影响到了服务层甚至数据库中的原始数据，这就麻烦了。这时候，我们通常会创建一个UserDTO，然后将User对象的内容拷贝到UserDTO中，再把UserDTO传出去。这样，Web层拿到的是一个独立的副本，怎么折腾都不会影响到原始的User对象。
实现不可变对象（Immutable Objects）的“修改”： 在Java里，像String、LocalDate这些都是不可变对象。你不能直接修改它们。但如果你想基于一个现有字符串创建一个“稍微不同”的新字符串（比如”hello”.replace(‘o’, ‘a’)），实际上是创建了一个全新的字符串对象。对于我们自定义的不可变对象，如果需要一个“修改后”的版本，最常用的方式就是提供一个类似withXxx()的方法，这个方法会创建一个新的实例，并将原实例的字段值拷贝过来，然后修改对应的字段，最后返回新实例。这里面就用到了拷贝的思路。
实现撤销/重做（Undo/redo）功能： 在很多编辑器或应用中，都有撤销和重做功能。要实现这个，你就需要保存对象在不同时间点的状态快照。每次用户执行一个操作，你就可以将当前对象的一个深拷贝保存到一个历史记录栈中。当用户点击“撤销”时，就从栈中取出上一个快照