Copy constructor v. implementing Cloneable interface

Question

In terms of "best practices", which methodology is preferred for creating a "deep copy" of an object?

Post

Use some cloning library: https://mcmap.net/q/93603/-deep-clone-utility-recommendation-closed – Godson

Answer 1

Use a copy constructor. Cloneable is a straight-up API disaster. See Effective Java Item 10 (Item 11 in the 2nd. ed.).

Item 11: Override clone judiciously

The Cloneable interface was intended as a mixin interface (item 18) for objects to advertise that they permit cloning. Unfortunately, it fails to serve this purpose. Its primary flaw is that it lacks a clone method, and Object's clone method is protected. You cannot, without resorting to reflection (Item 53), invoke the clone method on an object merely because it implements Cloneable. Even a reflective invocation may fail, as there is no guarantee that the object has an accessible clone method.

Gershwin

+1 (for the link, mostly) What about other alternatives to Cloneable, though? (A copy constructor generally requires a known concrete type, which while often is perfectly fine, is different from Cloneable.) – Tripodic

This quote also seems relevant to this question: " In effect, the clone method functions as another constructor; you must ensure that it does no harm to the original object and that it properly establishes invariants on the clone" – Tinfoil

Answer 2

There is nothing wrong with the general idea of a cloneable interface. It is easier than copy constructor for API users .

The problems with Java's Cloneable and Object.clone are not that bad either; they can be overcome with a little effort. And you can always have your own cloneable interface.

Java 8 could fix Cloneable by adding the clone() method with a default implementation

interface Cloneable
    public Object clone() default {  return Cloneables.defaultClone(this); }

not sure they have any plan to do so.

Delve

+1 for a great point about Java 8. Though I think an UnsupportedOperationException would be a safer default implementation for objects that haven't explicitly defined clone()..... – Exude