本文介绍了Java中Cloneable接口的作用和使用注意事项。首先，实现Cloneable接口是为了避免调用clone方法时抛出CloneNotSupportedException。其次，默认的clone方法执行的是浅拷贝，对象中可变引用对象的修改会影响克隆对象。最后，通过示例展示了如何实现深拷贝以确保对象的独立性。
JDK 版本：1.8
代码地址
1.前言
clone方法能方便的获得一个对象的拷贝，但其中也有些细节需要注意。
2.实现注意事项
2.1 要调用 clone 方法必须实现 Cloneable 接口
如果类没有实现 Cloneable 接口，类的实例却调用了 clone 方法，则会抛出CloneNotSupportedException异常。
用反射机制去调用 Objec 类的 clone 方法，可以观察到这个现象：
Object object = new Object();
Method method = object.getClass().getDeclaredMethod("clone");
method.setAccessible(true);
method.invoke(object);
运行结果：
Caused by: java.lang.CloneNotSupportedException: java.lang.Object
at java.lang.Object.clone(Native Method)
2.2 clone 方法的默认实现是浅拷贝
clone 方法的默认实现是拷贝，即对于类中可变对象没有进行真正的拷贝，只是将该可变对象赋值给了克隆对象对应的字段。修改当前对象中可变对象也会影响到克隆对象中相应的字段。
举个例子来说明下：
private static void shallowCopyTest() {
Person ming = new Person("ming", new String[]{"mingMing", "daMing"});
compareCloneObject(ming);
}
private static void compareCloneObject(Person person) {
try {
Person fakePerson = (Person) person.clone();
System.out.println("person.getNickName() == fakePerson.getNickName() : "
+ (person.getNickName() == fakePerson.getNickName()));
fakePerson.setNickName(0, "compare");
System.out.println(person);
System.out.println(fakePerson);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
private static class Person implements Cloneable {
private String name;
private String[] nickName;
public Person(String name, String[] nickName) {
this.name = name;
this.nickName = nickName;
}
public void setNickName(int index, String nickName) {
this.nickName[index] = nickName;
}
public void setNickName(String[] nickName) {
this.nickName = nickName;
}
public String[] getNickName() {
return nickName;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", nickName=" + Arrays.toString(nickName) +
'}';
}
}
调用shallowCopyTest方法，输出结果为：
person.getNickName() == fakePerson.getNickName() : true
Person{name='ming', nickName=[compare, daMing]}
Person{name='ming', nickName=[compare, daMing]}
可以看到原对象与克隆对象的 nickName 是同一个数组，更改一个以后另一个的值也发送相应变化。
2.3 深拷贝的实现
实现深拷贝要将对象类的所有可变对象都拷贝一遍，然后用拷贝的引用去替换掉原有的引用。
实现例子如下：
private static void deepCopyTest() {
Student ming = new Student("ming", new String[]{"mingMing", "daMing"}, "jiangNan");
compareCloneObject(ming);
}
public static class Student extends Person {
private String school;
public Student(String name, String[] nickName, String school) {
super(name, nickName);
this.school = school;
}
@Override
public Object clone() throws CloneNotSupportedException {
Student student = (Student) super.clone();
student.setNickName(this.getNickName().clone());
return student;
}
@Override
public String toString() {
return "Student{" +
"name='" + super.name + '\'' +
", nickName=" + Arrays.toString(super.nickName) +
", school='" + school + '\'' +
'}';
}
}
调用deepCopyTest方法，输出结果为：
person.getNickName() == fakePerson.getNickName() : false
Student{name='ming', nickName=[mingMing, daMing], school='jiangNan'}
Student{name='ming', nickName=[compare, daMing], school='jiangNan'}
可以看到两个对象 nickName 已经不是同一个对象了，改变之后也不会相互影响了。这是因为在覆写的 clone 方法中对 nickName 数组也进行了克隆，并赋值给克隆对象。
3.注释文档及个人翻译
/**
* A class implements the Cloneable interface to
* indicate to the {@link java.lang.Object#clone()} method that it
* is legal for that method to make a
* field-for-field copy of instances of that class.
*
* 一个类实现了 Cloneable 接口表示该类使用clone()方法来实现实例的逐字段的复制是合法的。
*
* Invoking Object's clone method on an instance that does not implement the
* Cloneable interface results in the exception
* CloneNotSupportedException being thrown.
*
* 在一个没有实现 Cloneable 接口的实例上调用 clone 方法将会抛出CloneNotSupportedException。
*
* By convention, classes that implement this interface should override
* Object.clone (which is protected) with a public method.
* See {@link java.lang.Object#clone()} for details on overriding this
* method.
* 按照惯例，实现该接口的类应该覆写Object.clone为一个公共方法。查看java.lang.Object#clone()
* 来获取更多细节。
*
*
* Note that this interface does not contain the clone method.
* Therefore, it is not possible to clone an object merely by virtue of the
* fact that it implements this interface. Even if the clone method is invoked
* reflectively, there is no guarantee that it will succeed.
* 注意：本接口不包含 clone 方法。因此，不能仅凭仅仅实现了本接口来克隆对象，即使是反射式调用，
* 也不能保证成功。
* @author unascribed
* @see java.lang.CloneNotSupportedException
* @see java.lang.Object#clone()
* @since JDK1.0
*/
/**
* 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 {@code x}, the expression:
*
*
* x.clone() != x
* will be true, and that the expression:
*
*
* x.clone().getClass() == x.getClass()
* will be {@code true}, but these are not absolute requirements.
* While it is typically the case that:
*
*
* x.clone().equals(x)
* will be {@code true}, this is not an absolute requirement.
*
* 创建并返回一个对象的拷贝。拷贝的准确定义取决于对象的类定义。普遍的来说，对任意对象 x，
* 表达式：x.clone() ! = x 的值是 true，并且表达式：x.clone().getClass() == x.getClass()
* 的值是
* true，但这些要求并不是绝对的。并且通常表达式：x.clone().equals(x)的值也是 true，
* 这也不是绝对必要的条件。
*
* By convention, the returned object should be obtained by calling
* {@code super.clone}. If a class and all of its superclasses (except
* {@code Object}) obey this convention, it will be the case that
* {@code x.clone().getClass() == x.getClass()}.
*
* 按照惯例，应该通过调用 super.clone 来获取返回的对象。如果一个类及其所有超类(Object 除外)
* 都遵循此约定，则 x.clone().getClass() == x.getClass() 成立。
*
* By convention, the object returned by this method should be independent
* of this object (which is being cloned). To achieve this independence,
* it may be necessary to modify one or more fields of the object returned
* by {@code super.clone} before returning it. Typically, this means
* copying any mutable objects that comprise the internal "deep structure"
* of the object being cloned and replacing the references to these
* objects with references to the copies. If a class contains only
* primitive fields or references to immutable objects, then it is usually
* the case that no fields in the object returned by {@code super.clone}
* need to be modified.
*
* 按照惯例，被本方法返回的对象应该与被克隆的原本对象无关。为了实现这种独立，可能需要在
* 克隆方法返回前修改被返回对象的字段。通常，这意味着拷贝构成被克隆对象的内部“深度结构”
* 的任何可变对象，并用拷贝的引用替换掉原本对象的引用。如果一个类仅仅包含原始字段或不可
* 变对象的引用，那么通常super.clone返回对象中没有字段需要被修改。
*
* The method {@code clone} for class {@code Object} performs a
* specific cloning operation. First, if the class of this object does
* not implement the interface {@code Cloneable}, then a
* {@code CloneNotSupportedException} is thrown. Note that all arrays
* are considered to implement the interface {@code Cloneable} and that
* the return type of the {@code clone} method of an array type {@code T[]}
* is {@code T[]} where T is any reference or primitive type.
* Otherwise, this method creates a new instance of the class of this
* object and initializes all its fields with exactly the contents of
* the corresponding fields of this object, as if by assignment; the
* contents of the fields are not themselves cloned. Thus, this method
* performs a "shallow copy" of this object, not a "deep copy" operation.
*
* Object 类的 clone 方法执行特定的克隆操作。首先，如果对象的类没有实现 Cloneable
* 接口，那么会抛出 CloneNotSupportedException 异常。请注意，所有的数组都被视为实
* 现了 Cloneable 接口，并且 T[] 类型数组 clone 接口的返回类型是 T[]，此处 T 可以
* 是任意引用类型或原始类型。除此之外，此方法创建一个对象的类的新实例，然后用原本对象对
* 应字段内容来初始化新实例所有字段，就像赋值；字段的内容不会被克隆。因此，此方法对对象
* 执行了“浅拷贝”而不是一个“深拷贝”。
*
* The class {@code Object} does not itself implement the interface
* {@code Cloneable}, so calling the {@code clone} method on an object
* whose class is {@code Object} will result in throwing an
* exception at run time.
* Object 类自身没有实现 Cloneable 接口，所以当对一个 Object 类的实例调用 clone
* 方法时将会在运行时抛出异常。
* @return a clone of this instance.
* @throws CloneNotSupportedException if the object's class does not
* support the {@code Cloneable} interface. Subclasses
* that override the {@code clone} method can also
* throw this exception to indicate that an instance cannot
* be cloned.
* @see java.lang.Cloneable
*/
protected native Object clone() throws CloneNotSupportedException;
扫一扫
1083
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
