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

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

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

解决方案

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

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

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

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

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

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）

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

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

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），然后从该流中读取回来，这样就创建了一个全新的对象图。实现：所有需要被序列化的类（包括其所有引用类型的字段）都必须实现Serializable接口。使用ObjectOutputStream将对象写入字节数组。使用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 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）功能：在很多编辑器或应用中，都有撤销和重做功能。要实现这个，你就需要保存对象在不同时间点的状态快照。每次用户执行一个操作，你就可以将当前对象的一个深拷贝保存到一个历史记录栈中。当用户点击“撤销”时，就从栈中取出上一个快照

以上就是如何使用Java实现拷贝构造 Java复制对象的实现技巧的详细内容，更多请关注创想鸟其它相关文章！