前言

本章介绍 Java 的对象克隆，并给出常见的使用案例。

版本约定

JDK Version：11.0.12
Java SE API Documentation：https://docs.oracle.com/en/java/javase/11/docs/api/index.html
正文
什么是 Java clone？

克隆是原始对象的精确拷贝。在 Java 中，它本质上意味着能够创建一个与原始对象状态相似的对象。Java 的 clone() 方法提供了这个功能。

默认情况下，Java 的克隆是“逐字段复制”（field by field copy），也就是说，Object 类并不了解将被调用的 clone() 方法的类的结构。

因此，JVM 在进行克隆时，会做以下事情。

如果类只有原始数据类型的成员，那么将创建一个全新的对象副本，并返回对新对象副本的引用。
如果类包含任何引用类型的成员，那么只有这些成员的对象引用被复制，因此原始对象和克隆对象中的成员引用都指向同一个对象。

除了上述默认行为外，你可以随时覆盖这一行为，并指定你自己的行为。这可以通过覆盖 clone() 方法来实现。让我们看看它是如何做到的。

使用 Cloneable 接口和 clone() 方法实现克隆

每种支持克隆对象的语言都有自己的规则，Java 也是如此。在 Java 中，如果一个类需要支持克隆，它必须要做以下事情。

你必须实现 Cloneable 接口。
你必须覆盖 Object 类中的 clone() 方法（这很奇怪，Clone() 方法应该在 Cloneable 接口中）。

Cloneable 接口没有指定 clone 方法，这个方法是从 Object 类继承的。这个接口只是作为一个标记，指示类设计者了解克隆过程。对象对于克隆很“偏执”，如果一个对象请求克隆，但没有实现这个接口，就会生成一个受查异常。

根据上面的规则，即使 clone 的默认（浅拷贝）实现能够满足要求，还是需要实现 Cloneable 接口，将 clone 重新定义为 public，再调用 super.clone()。

关于 clone() 方法的 Java 文档如下所示：

/**
 * Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object.
 * The general intent is that, for any object x, the expression:
 * 1) x.clone() != x, will be true.
 * 2) x.clone().getClass() == x.getClass(), will be true, but these are not absolute requirements.
 * 3) x.clone().equals(x), will be true, this is not an absolute requirement.
 */
protected native Object clone() throws CloneNotSupportedException;

第一条语句保证了克隆的对象将有独立的内存地址分配。
第二条语句建议原始对象和克隆对象应该具有相同的类型，但这并不是强制性的。
第三条语句建议原始对象和克隆对象在使用 equals() 方法比较的时候，应该是相等的，但这并不是强制性的。

让我们通过例子来理解 Java 克隆。我们的第一个类是 Employee 类，有 3 个属性：id，name 和 department。

public class Employee implements Cloneable {
    private int id;
    private String name;
    private Department department;
    public Employee(int id, String name, Department dept) {
        this.id = id;
        this.name = name;
        this.department = dept;
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    // Getters and Setters
}

Department 类有两个属性：id 和 name。

public class Department {
    private int id;
    private String name;
    public Department(int id, String name) {
        this.id = id;
        this.name = name;
    }
    // Getters and Setters
}

因此，如果我们需要克隆 Employee 类，那么我们需要执行如下操作。

public class TestCloning {
    public static void main(String[] args) throws CloneNotSupportedException {
        Department dept = new Department(1, "Human Resource");
        Employee original = new Employee(1, "Admin", dept);
        // Lets create a clone of original object
        Employee cloned = (Employee) original.clone();
        // Let verify using employee id, if cloning actually workded
        System.out.println("cloned.getId(): " + cloned.getId());
        // Verify JDK's rules
        // Must be true and objects must have different memory addresses
        System.out.println("original != cloned: " + (original != cloned));
        // As we are returning same class; so it should be true
        System.out.println("original.getClass() == cloned.getClass(): " + (original.getClass() == cloned.getClass()));
        // Default equals method checks for references so it should be false. If we want to make it true,
        // then we need to override equals method in Employee class.
        System.out.println("original.equals(cloned): " + original.equals(cloned));
    }
}

运行程序，输出：

cloned.getId(): 1
original != cloned: true
original.getClass() == cloned.getClass(): true
original.equals(cloned): false

我们成功地克隆了 Employee 对象。但是，department 对象只是引用被复制，现在来改变克隆对象中 department 对象的状态，看看是否会对原始对象有影响。

public class TestCloning {
    public static void main(String[] args) throws CloneNotSupportedException {
        Department hr = new Department(1, "Human Resource");
        Employee original = new Employee(1, "Admin", hr);
        Employee cloned = (Employee) original.clone();
        // Let change the department name in cloned object and we will verify in original object
        cloned.getDepartment().setName("Finance");
        System.out.println("original.getDepartment().getName(): " + original.getDepartment().getName());
        System.out.println("cloned.getDepartment().getName(): " + cloned.getDepartment().getName());
    }
}

运行程序，输出：

original.getDepartment().getName(): Finance
cloned.getDepartment().getName(): Finance

通过上面的测试，我们知道克隆对象的变化在原始对象中也是可见的。这样，如果允许克隆对象，克隆对象可能会在系统中造成严重破坏。任何人都可以来克隆应用程序中的对象，并执行他喜欢的任何操作。我们能防止这种情况吗？

答案是肯定的，我们可以通过 Java 深拷贝来防止这种情况。让我们首先看看 Java 中的深拷贝和浅拷贝是什么。

Java 浅拷贝

Java 默认的克隆操作是“浅拷贝”，并没有克隆对象中引用的其他对象。在重载的 clone 方法中，如果你没有克隆所有的引用类型，那么你就是在做一个浅拷贝。

以上所有的例子都是浅拷贝，因为我们没有在 Employee 类的克隆方法中克隆 Department 对象。

下图显示了 Employee 对象的浅拷贝会发生什么。
对象克隆 - 图1
浅拷贝会有什么影响？这样看具体情况。如果原对象和浅拷贝对象共享的子对象是不可变的，那么这种共享就是安全的。比如，子对象属于一个不可变的类（如 String），这种情况是安全的。或者在对象的生命期中，子对象是一个不可变的常量，没有构造方法能改变它，也没有方法可以生成它的引用，这种情况下同样是安全的。

Java 深拷贝

不过，通常子对象都是可变的，必须重新定义 clone 方法来建立一个深拷贝，同时克隆所有子对象。

在深拷贝中，我们创建了一个独立于原始对象的克隆，对克隆对象的改变不应影响原始对象。

让我们看看在 Java 中是如何创建深度拷贝的。

// Modified clone() method in Employee class
@Override
public Object clone() throws CloneNotSupportedException {
    Employee cloned = (Employee) super.clone();
    cloned.department = (Department) department.clone();
    return cloned;
}

我修改了 Employee 类的 clone() 方法，并在 Department 类中加入了以下的 clone 方法。

// Defined clone method in Department class.
@Override
public Object clone() throws CloneNotSupportedException {
    return super.clone();
}

现在测试我们的克隆代码，可以得到理想的结果，部门的名称不会被修改。

public class TestCloning {
    public static void main(String[] args) throws CloneNotSupportedException {
        Department hr = new Department(1, "Human Resource");
        Employee original = new Employee(1, "Admin", hr);
        Employee cloned = (Employee) original.clone();
        // Let change the department name in cloned object and we will verify in original object
        cloned.getDepartment().setName("Finance");
        System.out.println("original.getDepartment().getName(): " + original.getDepartment().getName());
        System.out.println("cloned.getDepartment().getName(): " + cloned.getDepartment().getName());
    }
}

运行程序，输出：

original.getDepartment().getName(): Human Resource
cloned.getDepartment().getName(): Finance

改变克隆对象的状态并不影响原始对象。

因此，深度克隆需要满足以下规则：

不需要单独复制原始类型。
原始类中的所有成员类都应支持克隆，并且在上下文中原始类的克隆方法中应在所有成员类上调用super.clone()。
如果任何成员类不支持克隆，则在 clone 方法中，必须创建一个该成员类的新实例，并将其所有属性逐个复制到新的成员类对象。此新成员类对象将被设置在克隆的对象中。
使用构造器实现克隆

拷贝构造函数是类中的特殊构造函数，它接受的参数是自己的类类型。因此，当你把一个类的实例传递给复制构造函数时，构造函数将返回一个新的类的实例，其值是从参数实例中复制的。它可以帮助你通过 Cloneable 接口来克隆对象。

让我们来看个例子。

public class PointOne {
    private Integer x;
    private Integer y;
    public PointOne(PointOne point) {
        this.x = point.x;
        this.y = point.y;
    }
    // Other construct
    // Getters and Setters
}

这种方法看起来很简单，直到继承。当你通过扩展父类来定义一个类时，还需要在那里定义一个类似的构造函数。在子类中，你需要复制子类的特定属性，并将参数传递给超类的构造函数。让我们看看是如何实现的？

public class PointTwo extends PointOne {
    private Integer z;
    public PointTwo(PointTwo point) {
        super(point); //Call Super class constructor here
        this.z = point.z;
    }
    // Other construct
    // Getters and Setters
}

这样实现克隆是存在一定问题的。比如，在上面的例子中，如果我们将 PointTwo 的实例传递给 PointOne 的构造函数，在这种情况下，会得到一个 PointOne 的实例。

public class Test {
    public static void main(String[] args) {
        PointOne one = new PointOne(1, 2);
        PointTwo two = new PointTwo(1, 2, 3);
        PointOne clone1 = new PointOne(one);
        PointOne clone2 = new PointOne(two);
        //Let check for class types
        System.out.println(clone1.getClass());
        System.out.println(clone2.getClass());
    }
}

运行程序，输出：

class test15.PointOne
class test15.PointOne

创建复制构造函数的另一种方法是拥有静态工厂方法。它们在参数中接受类的类型，并使用该类的另一个构造函数创建一个新的实例。然后这些工厂方法会将所有的状态数据复制到上一步刚刚创建的新类实例中，并返回这个新的实例。

public class PointOne implements Cloneable {
    private Integer x;
    private Integer y;
    public PointOne(Integer x, Integer y) {
        this.x = x;
        this.y = y;
    }
    public PointOne copyPoint(PointOne point) throws CloneNotSupportedException {
        if (!(point instanceof Cloneable)) {
            throw new CloneNotSupportedException("Invalid cloning");
        }
        // Can do multiple other things here
        return new PointOne(point.x, point.y);
    }
}

使用 Java 拷贝构造器克隆对象是比较繁琐的，特别是当类的字段比较多时更加麻烦，不推荐使用该方式。

使用序列化实现深拷贝

序列化是深度克隆的另一种简单方法。在这个方法中，你只需将要克隆的对象序列化，然后将其反序列化。很明显，需要克隆的对象应该实现 Serializable 接口。

这种技术不能轻易使用，它存在如下问题。

首先，序列化性能不高。它可能很容易比 clone() 方法多消耗 100 倍时间。
其次，不是所有的对象都是可序列化的。

第三，让一个类成为可序列化（Serializable）的类是很棘手的，并不是所有的类都能靠它来完成。

@SuppressWarnings("unchecked")
public static <T extends Serializable> T clone(T t) throws Exception {
 // Serialize it
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 ObjectOutputStream oos = new ObjectOutputStream(baos);
 oos.writeObject(t);
 oos.close();
 // Deserialize it and return the new instance
 ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
 ObjectInputStream ois = new ObjectInputStream(bais);
 T clone = (T) ois.readObject();
 ois.close();
 return clone;
}

不需要我们自己实现序列化方法，在 Apache commons 中，SerializationUtils 类已经提供了使用序列化实现深拷贝的方法。

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

SomeObject cloned = SerializationUtils.clone(someObject);

总结

首先，对象克隆推荐使用 Java 自带的 clone() 方法，性能较高，只是需要我们自己实现深拷贝功能。
其次，在不考虑性能的前提下，也可以使用第三方工具 SerializationUtils 类提供的使用序列化实现深拷贝的方法。
另外，在下篇文章中介绍的对象复制工具 Orika，也是比较推荐的，性能相比其他的一些工具会好很多。
所有数组类型都有一个 public 的 clone 方法，可以用这个方法克隆一个新数组，包含原数组所有元素的副本，需要注意的是，数组的克隆是浅拷贝。

参考
Java 核心技术卷1 基础知识第10版
Java clone – deep and shallow copy – copy constructors

作者：殷建卫链接：https://www.yuque.com/yinjianwei/vyrvkf/emnayh 来源：殷建卫 - 开发笔记著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

对象克隆

前言

版本约定

正文

什么是 Java clone？

使用 Cloneable 接口和 clone() 方法实现克隆

Java 浅拷贝

Java 深拷贝

使用构造器实现克隆

使用序列化实现深拷贝

总结

参考