我需要在我的一个没有超类的对象中实现深度克隆。
CloneNotSupportedException处理超类（即）抛出的检查的最佳方法是Object什么？
一位同事建议我按以下方式处理：
@Override
public MyObject clone()
{
MyObject foo;
try
{
foo = (MyObject) super.clone();
}
catch (CloneNotSupportedException e)
{
throw new Error();
}
// Deep clone member fields here
return foo;
}
这对我来说似乎是一个很好的解决方案，但我想把它扔给 StackOverflow 社区，看看是否还有其他可以包含的见解。谢谢！
Do you absolutely have to use clone? Most people agree that Java's clone is broken.
Josh Bloch on Design - Copy Constructor versus Cloning
If you've read the item about cloning in my book, especially if you read between the lines, you will know that I think
cloneis deeply broken. [...] It's a shame thatCloneableis broken, but it happens.
You may read more discussion on the topic in his book Effective Java 2nd Edition, Item 11: Override clone judiciously. He recommends instead to use a copy constructor or copy factory.
He went on to write pages of pages on how, if you feel you must, you should implement clone. But he closed with this:
Is all this complexities really necessary? Rarely. If you extend a class that implements
Cloneable, you have little choice but to implement a well-behavedclonemethod. Otherwise, you are better off providing alternative means of object copying, or simply not providing the capability.
The emphasis was his, not mine.
Since you made it clear that you have little choice but to implement clone, here's what you can do in this case: make sure that MyObject extends java.lang.Object implements java.lang.Cloneable. If that's the case, then you can guarantee that you will NEVER catch a CloneNotSupportedException. Throwing AssertionError as some have suggested seems reasonable, but you can also add a comment that explains why the catch block will never be entered in this particular case.
Alternatively, as others have also suggested, you can perhaps implement clone without calling super.clone.
Sometimes it's more simple to implement a copy constructor:
public MyObject (MyObject toClone) {
}
It saves you the trouble of handling CloneNotSupportedException, works with final fields and you don't have to worry about the type to return.
The way your code works is pretty close to the "canonical" way to write it. I'd throw an AssertionError within the catch, though. It signals that that line should never be reached.
catch (CloneNotSupportedException e) {
throw new AssertionError(e);
}
There are two cases in which the CloneNotSupportedException will be thrown:
Cloneable (assuming that the actual cloning eventually defers to Object's clone method). If the class you are writing this method in implements Cloneable, this will never happen (since any sub-classes will inherit it appropriately).Cloneable.The latter case cannot occur in your class (as you're directly calling the superclass' method in the try block, even if invoked from a subclass calling super.clone()) and the former should not since your class clearly should implement Cloneable.
Basically, you should log the error for sure, but in this particular instance it will only happen if you mess up your class' definition. Thus treat it like a checked version of NullPointerException (or similar) - it will never be thrown if your code is functional.
In other situations you would need to be prepared for this eventuality - there is no guarantee that a given object is cloneable, so when catching the exception you should take appropriate action depending on this condition (continue with the existing object, take an alternative cloning strategy e.g. serialize-deserialize, throw an IllegalParameterException if your method requires the parameter by cloneable, etc. etc.).
Edit: Though overall I should point out that yes, clone() really is difficult to implement correctly and difficult for callers to know whether the return value will be what they want, doubly so when you consider deep vs shallow clones. It's often better just to avoid the whole thing entirely and use another mechanism.
Use serialization to make deep copies. This is not the quickest solution but it does not depend on the type.
您可以像这样实现受保护的复制构造函数：
/* This is a protected copy constructor for exclusive use by .clone() */
protected MyObject(MyObject that) {
this.myFirstMember = that.getMyFirstMember(); //To clone primitive data
this.mySecondMember = that.getMySecondMember().clone(); //To clone complex objects
// etc
}
public MyObject clone() {
return new MyObject(this);
}
尽管这里的大多数答案都是有效的，但我需要告诉您，您的解决方案也是实际的 Java API 开发人员如何做到的。（乔什·布洛赫或尼尔·加夫特）
以下是 openJDK ArrayList 类的摘录：
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
正如您已经注意到和其他人提到的，CloneNotSupportedException如果您声明您实现了Cloneable接口，几乎没有机会被抛出。
此外，如果您在被覆盖的方法中没有做任何新的事情，您也不需要覆盖该方法。只有在需要对对象进行额外操作或需要将其公开时才需要覆盖它。
最终，最好还是避免它并使用其他方式进行。
public class MyObject implements Cloneable, Serializable{
@Override
@SuppressWarnings(value = "unchecked")
protected MyObject clone(){
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
ByteArrayOutputStream bOs = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bOs);
oos.writeObject(this);
ois = new ObjectInputStream(new ByteArrayInputStream(bOs.toByteArray()));
return (MyObject)ois.readObject();
} catch (Exception e) {
//Some seriouse error :< //
return null;
}finally {
if (oos != null)
try {
oos.close();
} catch (IOException e) {
}
if (ois != null)
try {
ois.close();
} catch (IOException e) {
}
}
}
}
仅仅因为 java 的 Cloneable 实现被破坏，并不意味着您不能创建自己的实现。
如果 OP 的真正目的是创建一个深度克隆，我认为可以创建这样的界面：
public interface Cloneable<T> {
public T getClone();
}
然后使用前面提到的原型构造函数来实现它：
public class AClass implements Cloneable<AClass> {
private int value;
public AClass(int value) {
this.vaue = value;
}
protected AClass(AClass p) {
this(p.getValue());
}
public int getValue() {
return value;
}
public AClass getClone() {
return new AClass(this);
}
}
和另一个具有 AClass 对象字段的类：
public class BClass implements Cloneable<BClass> {
private int value;
private AClass a;
public BClass(int value, AClass a) {
this.value = value;
this.a = a;
}
protected BClass(BClass p) {
this(p.getValue(), p.getA().getClone());
}
public int getValue() {
return value;
}
public AClass getA() {
return a;
}
public BClass getClone() {
return new BClass(this);
}
}
通过这种方式，您可以轻松地深度克隆 BClass 类的对象，而无需 @SuppressWarnings 或其他花哨的代码。