The rules above allow for covariant return types - re ning the return type of a method when overriding it For example, the following declarations are legal although they were illegal in prior versions of the Java programming language:

class C implements Cloneable { C copy() { return (C)clone(); } } class D extends C implements Cloneable { D copy() { return (D)clone(); } }

The relaxed rule for overriding also allows one to relax the conditions on abstract classes implementing interfaces

class StringSorter { // takes a collection of strings and converts it to a sortedlist List toList(Collection c) {} }

class Overrider extends StringSorter{ List toList(Collection c) {} }

class StringSorter { // takes a collection of strings and converts it to a list List<String> toList(Collection<String> c) {} }

An unchecked warning would be given when compiling Overrider against the new de nition of StringSorter because the return type of OverridertoList() is List, which is not a subtype of the return type of the overridden method, List<String

In these respects, overriding of methods differs from hiding of elds ( 83), for it is permissible for a eld to hide a eld of another type

It is a compile time error if a type declaration T has a member method m1 and there exists a method m2 declared in T or a supertype of T such that all of the following conditions hold: m1 and m2 have the same name m2 is accessible from T The signature of m1 is not a subsignature ( 842) of the signature of m2 m1 or some method m1 overrides (directly or indirectly) has the same erasure as m2 or some method m2 overrides (directly or indirectly)

class C<T> { T id (T x) {} } class D extends C<String> { Object id(Object x) {} }

This is illegal since Did(Object) is a member of D, C<String>id(String) is declared in a supertype of D and: The two methods have the same name, id The signature of Did(Object) C<String>id(String) C<String>id(String) is accessible to D is

These restrictions are necessary because generics are implemented via erasure The rule above implies that methods declared in the same class with the same name must have different erasures It also implies that a type declaration cannot implement or extend two distinct invocations of the same generic interface Here are some further examples A class cannot have two member methods with the same name and type erasure

class C<T> { T id (T x) {} } interface I<T> { Tid(T x); } class D extends C<String> implements I<Integer> {

String id(String x) {} Integer id(Integer x) {} }

This is also illegal, since Did(String) is a member of D, declared in D and: the two methods have the same name, id the two methods have different signatures Did(Integer) is accessible to D

The access modi er ( 66) of an overriding or hiding method must provide at least as much access as the overridden or hidden method, or a compile-time error occurs In more detail: If the overridden or hidden method is public, then the overriding or hiding method must be public; otherwise, a compile-time error occurs

If the overridden or hidden method is protected, then the overriding or hiding method must be protected or public; otherwise, a compile-time error occurs If the overridden or hidden method has default (package) access, then the overriding or hiding method must not be private; otherwise, a compile-time error occurs Note that a private method cannot be hidden or overridden in the technical sense of those terms This means that a subclass can declare a method with the same signature as a private method in one of its superclasses, and there is no requirement that the return type or throws clause of such a method bear any relationship to those of the private method in the superclass 8484 Inheriting Methods with Override-Equivalent Signatures

It is possible for a class to inherit multiple methods with override-equivalent ( 842) signatures It is a compile time error if a class C inherits a concrete method whose signatures is a subsignature of another concrete method inherited by C

Did(String) overrides C<String>id(String) and Did(Integer) overrides Iid(Integer) yet the two overridden methods have the same erasure