Java拷贝构造实现方法全解析

你在学习文章相关的知识吗？本文《Java拷贝构造实现方法详解》，主要介绍的内容就涉及到，如果你想提升自己的开发能力，就不要错过这篇文章，大家要知道编程理论基础和实战操作都是不可或缺的哦！

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

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

解决方案

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

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

这是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）

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

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

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()方法的“槽点”：

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

拷贝构造器的优势：

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

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

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

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

1. 数据传输对象（DTO）/值对象（Value Object）的隔离： 想象一下，你的服务层从数据库取出了一个User对象，然后要把它传递给Web层展示。如果直接把这个User对象传过去，Web层可能会无意中修改了User对象的某个属性，而这个修改又“反向”影响到了服务层甚至数据库中的原始数据，这就麻烦了。这时候，我们通常会创建一个UserDTO，然后将User对象的内容拷贝到UserDTO中，再把UserDTO传出去。这样，Web层拿到的是一个独立的副本，怎么折腾都不会影响到原始的User对象。

2. 实现不可变对象（Immutable Objects）的“修改”： 在Java里，像String、LocalDate这些都是不可变对象。你不能直接修改它们。但如果你想基于一个现有字符串创建一个“稍微不同”的新字符串（比如"hello".replace('o', 'a')），实际上是创建了一个全新的字符串对象。对于我们自定义的不可变对象，如果需要一个“修改后”的版本，最常用的方式就是提供一个类似withXxx()的方法，这个方法会创建一个新的实例，并将原实例的字段值拷贝过来，然后修改对应的字段，最后返回新实例。这里面就用到了拷贝的思路。

3. 实现撤销/重做（Undo/Redo）功能： 在很多编辑器或应用中，都有撤销和重做功能。要实现这个，你就需要保存对象在不同时间点的状态快照。每次用户执行一个操作，你就可以将当前对象的一个深拷贝保存到一个历史记录栈中。当用户点击“撤销”时，就从栈中取出上一个快照

到这里，我们也就讲完了《Java拷贝构造实现方法全解析》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于浅拷贝,深拷贝,对象拷贝,拷贝构造器,clone()方法的知识点！