Effective Java

Public 
clone
 methods should omit the 
throws
clause
, as methods that don’t throw checked exceptions are easier to use (Item 71).
You have two choices when designing a class for inheritance (Item 19), but
whichever one you choose, the class should 
not
implement 
Cloneable
. You may
choose to mimic the behavior of 
Object
by implementing a properly functioning
protected 
clone
method that is declared to throw 
CloneNotSupportedException
.
This gives subclasses the freedom to implement 
Cloneable
or not, just as if they
extended 
Object
directly. Alternatively, you may choose 
not
to implement a
working 
clone
method, and to prevent subclasses from implementing one, by
providing the following degenerate 
clone
implementation:
// clone method for extendable class not supporting Cloneable
@Override
protected final Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
There is one more detail that bears noting. If you write a thread-safe class that
implements 
Cloneable
, remember that its 
clone
method must be properly syn-
chronized, just like any other method (Item 78). 
Object
’s 
clone
method is not
synchronized, so even if its implementation is otherwise satisfactory, you may
have to write a synchronized 
clone
method that returns 
super.clone()
.
To recap, all classes that implement 
Cloneable
should override 
clone
with a
public method whose return type is the class itself. This method should first call
super.clone
, then fix any fields that need fixing. Typically, this means copying
any mutable objects that comprise the internal “deep structure” of the object and
replacing the clone’s references to these objects with references to their copies.

---

ITEM 13: OVERRIDE CLONE JUDICIOUSLY
65
While these internal copies can usually be made by calling 
clone
recursively, this
is not always the best approach. If the class contains only primitive fields or refer-
ences to immutable objects, then it is likely the case that no fields need to be fixed.
There are exceptions to this rule. For example, a field representing a serial number
or other unique ID will need to be fixed even if it is primitive or immutable.
Is all this complexity really necessary? Rarely. If you extend a class that
already implements 
Cloneable
, you have little choice but to implement a well-
behaved 
clone
method. Otherwise, you are usually better off providing an
alternative means of object copying.