This week's book giveaway is in the OO, Patterns, UML and Refactoring forum. We're giving away four copies of Refactoring for Software Design Smells: Managing Technical Debt and have Girish Suryanarayana, Ganesh Samarthyam & Tushar Sharma on-line! See this thread for details.
If the "protected" access atribute means access only through subclasses and if Object class is on the top of the hierarchy with all the other classes being its subclasses, why is clone() method protected then? Maybe because sometimes we would need to override it with a clone() that has more-restrictive-than-public atribute? If so, when does such a need arise?
Almost, I think. Suppose it was public. That means that you can call clone() from any other class. Now - you don't want to do this, because you want to control the call for clone() on your objects. Also, you can always declare your class final - and that's where you end the inheritance. So - if you can't extend class X - you can't get its clone() method as well. Nimo.
clone() is a mystery wrapped in a riddle: (1) clone() will not function unless class also implements Cloneable (2) Object itself doesn't implement Cloneable, so you can't invoke clone() directly .. only on a Cloneable sub-class (3) Even as a sub-class of Object, you can't clone() unless you implement the Cloneable interface, yet the Cloneable interface (like Serializable) has no methods! Viewed this way, the 'protected' modifier makes sense:-) The bigger picture adds up to a restrictive invocation environment for clone() since neither cloning nor serialization are not guaranteed to succeed (especially on 'mutable' objects), it is probably healthy to be forced to do an explicit implementation, and deal with exceptions then and there there's also a security perspective - if you could clone() *all* Object subclasses by default ... security would be, well, pretty messy. As it is, you have much more control. You can 1. implement Cloneable, and let Object manage the clone() , and just handle exceptions, 2. implement Cloneable, and explicitly manage (what gets cloned and how) in your clone() method 3. passively prohibit cloning of your objects by *not* implementing Cloneable, or 4. actively prohibit cloning by implementing Cloneable and throwing a CloneNotSupportedException in the clone() method