Why is Cloneable not deprecated?

by

There is a bug submitted in 1997 to Java Bug Database about adding clone() method to Cloneable, so it would no longer be useless. It was closed with resolution “won’t fix” and justification was as follows:

Sun’s Technical Review Committee (TRC) considered this issue at length
and recommended against taking any action other than improving the
documentation of the current Cloneable interface. Here is the full
text of the recommendation:

The existing Java object cloning APIs are problematic. There is a
protected “clone” method on java.lang.Object and there is an interface
java.lang.Cloneable. The intention is that if a class wants to allow
other people to clone it, then it should support the Cloneable
interface and override the default protected clone method with a
public clone method. Unfortunately, for reasons conveniently lost in
the mists of time, the Cloneable interface does not define a clone
method.

This combination results in a fair amount of confusion. Some classes
claim to support Cloneable, but accidentally forget to support the
clone method. Developers are confused about how Cloneable is supposed
to work and what clone is supposed to do.

Unfortunately, adding a “clone” method to Cloneable would be an
incompatible change. It won’t break binary compatibility, but it will
break source compatibility. Anecdotal evidence suggests that in
practice there are a number of cases where classes support the
Cloneable interface but fail to provide a public clone method. After
discussion, TRC unanimously recommended that we should NOT modify the
existing Cloneable interface, because of the compatibility impact.

An alternative proposal was to add a new interface
java.lang.PubliclyCloneable to reflect the original intended purpose
of Cloneable. By a 5 to 2 majority, TRC recommended against this.
The main concern was that this would add yet more confusion (including
spelling confusion!) to an already confused picture.

TRC unanimously recommended that we should add additional
documentation to the existing Cloneable interface to better describe
how it is intended to be used and to describe “best practices” for
implementors.

So, although this is not directly about deprecated, the reason for not making Cloneable “deprecated” is that Technical Review Comitee decided that modifying existing documentation will be sufficient enough to make this interface useful. And so they did. Until Java 1.4, Cloneable was documented as follows:

A class implements the Cloneable interface to indicate to the
Object.clone() method that it is legal for that method to make a
field-for-field copy of instances of that class.

Attempts to clone instances that do not implement the Cloneable
interface result in the exception CloneNotSupportedException being
thrown.

The interface Cloneable declares no methods.

Since Java 1.4 (which was released in February 2002) up to current edition (Java 8) it looks like this:

A class implements the Cloneable interface to indicate to the
Object.clone() method that it is legal for that method to make a
field-for-field copy of instances of that class. Invoking Object’s
clone method on an instance that does not implement the Cloneable
interface results in the exception CloneNotSupportedException being
thrown.

By convention, classes that implement this interface should override
Object.clone (which is protected) with a public method. See
Object.clone() for details on overriding this method.

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.

More Related Contents:

  1. Observer is deprecated in Java 9. What should we use instead of it?
  2. Can Java 8 code be compiled to run on Java 7 JVM?
  3. Is method reference caching a good idea in Java 8?
  4. Java 8: Lambda-Streams, Filter by Method with Exception
  5. Class has been compiled by a more recent version of the Java Environment
  6. Android Studio Error: Error:CreateProcess error=216, This version of %1 is not compatible with the version of Windows you’re running
  7. How can I create a stream from an array?
  8. Why does this generic code compile in java 8?
  9. Sum values from specific field of the objects in a list
  10. How do I define a method which takes a lambda as a parameter in Java 8?
  11. What’s the difference between instance method reference types in Java 8?
  12. Why are Java 8 lambdas invoked using invokedynamic?
  13. Why do Consumers accept lambdas with statement bodies but not expression bodies?
  14. Most efficient way to get the last element of a stream
  15. Why does findFirst() throw a NullPointerException if the first element it finds is null?
  16. Java 8 Stream IllegalStateException: Stream has already been operated on or closed
  17. Horrendous performance & large heap footprint of Java 8 constructor reference?
  18. Modifying Objects within stream in Java8 while iterating
  19. Take every nth element from a Java 8 stream
  20. Static context cannot access non-static in Collectors
  21. How can I parse/format dates with LocalDateTime? (Java 8)
  22. Valid usage of Optional type in Java 8
  23. Why are new java.util.Arrays methods in Java 8 not overloaded for all the primitive types?
  24. installing JDK8 on Windows XP – advapi32.dll error
  25. Java 8, how can I implement a switch statement using streams?
  26. How to set format of string for java.time.Instant using objectMapper?
  27. When is an interface with a default method initialized?
  28. Android LocationServices.FusedLocationApi deprecated
  29. java: Arrays.sort() with lambda expression
  30. Cannot use Java 8 method with lambda arguments without specifying type arguments

Leave a Comment