How should the return type and access modifier of an overridden clone() be declared, and why?

## The base signature you are overriding On `java.lang.Object`: ```java protected Object clone() throws CloneNotSupportedException ``` Three friction points for callers: it is **protected** (not callable from outside the class/package/subclass), it returns **Object** (forces a cast), and it declares a **checked exception** (forces a try/catch even when impossible). ## Fix 1 — widen access to public Access modifiers in an override may only stay the same or **widen** (you can go protected→public, never public→protected). To let arbitrary callers clone your object you must override and declare it `public`: ```java @Override public Item clone() { ... } ``` If you leave it protected, `someItem.clone()` still won't compile from unrelated code. ## Fix 2 — covariant return type Since **Java 5**, an overriding method may declare a return type that is a **subtype** of the overridden method's return type — a **covariant return type**. Because every class is a subtype of `Object`, you can return your own class: ```java @Override public Item clone() { try { return (Item) super.clone(); } // cast needed INSIDE (super.clone() returns Object) catch (CloneNotSupportedException e) { throw new AssertionError(e); } } ``` The cast is needed *inside* the method (because `super.clone()` is typed as `Object`), but **callers** get `Item` directly: ```java Item copy = item.clone(); // no cast at the call site ``` Without covariance, every caller would write `(Item) item.clone()`. Covariant returns push that one cast into the single override and out of every call site. ## Fix 3 — drop the checked exception A class that implements `Cloneable` can never actually have `super.clone()` throw `CloneNotSupportedException`, so idiomatic overrides catch it internally and rethrow an `AssertionError`, removing the `throws` clause from the public signature. Callers then need no try/catch. ## Putting it together The conventional, caller-friendly clone override is: ```java public class Item implements Cloneable { @Override public Item clone() { // public + covariant return try { return (Item) super.clone(); } catch (CloneNotSupportedException e) { // impossible here throw new AssertionError(e); } } } ``` This trio — widen to public, covariant return, swallow the impossible exception — is what makes an inherited-from-`Object` `clone()` usable. (None of it fixes clone's deeper design problems; it just makes the *call site* clean.) ## Term definitions - **Covariant return type:** an override returning a subtype of the parent method's declared return type — permitted since Java 5. - **Widening access:** an override may make a member *more* accessible (protected→public) but never *less*; narrowing is a compile error.