java - Generic Method Covariance - valid restriction or compiler oversight? -

does know definitive answer why following isn't allowed java compiler?

class baseclass {        public <t extends number> t getnumber(){             return null;       } }  class subclass extends baseclass{        @override       public <t extends integer> t getnumber(){             return null;       }  } 

this causes compiler complain with:

"the method getnumber() of type subclass must override superclass method"

now, when put colleagues have tried explain cause confusion compiler. however, pointed out following, conceptually similar, compilable.

class baseclass<t extends number> {       public t getnumber(){             return null;        } }   class subclass<t extends integer> extends baseclass<t>{       @override          public  t getnumber(){             return null;        } } 

this can abused if subclass calls super implementation, compiler provides warning effect. conclusion compiler oversight on part of folks @ sun (can't bring myself oracle :-s).

anyone have definitive answer one?

suppose indeed allowed add more restrictions type parameter on derived class.

then if class had <t extends number> void setnumber(t number) method?

baseclass foo = new subclass(); long longvalue = 42; foo.<long>setnumber(longvalue);  

the above accepted compiler because baseclass.setnumber accepts type parameter derived number. actual instance accepts integers!

you argue if type parameter used return value, should automatically considered covariant. compiler have make sure don't use type parameter inside method body in non-covariant way.

(in c# 4.0 solved, involves explicitly marking type parameters covariant or contravariant out , in keywords. not allowed compiler without changing language.)