Re: correct usage for @SuppressWarnings("unchecked")
On 4/22/2010 4:13 AM, Steven Simpson wrote:
On 21/04/10 21:35, Lew wrote:
To put it another way, all you can say with certainty about the types
of 'List<Foo>' elements is that they are all of type 'Foo'. Each
element may be of some different subtype of 'Foo'. In the case of
'List<? extends Foo>', you can aver that every element is of type
'Foo'. You can also aver that every element is of some unidentified
subtype of 'Foo', which may be 'Foo' itself or some proper subtype.
I don't think you're making any distinction. /Whichever type is used/,
all you know is that the elements are all 'instanceof Foo', and you
don't know that their #getClass() methods return the same value.
(That's two interpretations of "all of type 'Foo'", whichever you
intended; is there another?)
If anything, the<? extends Foo> form tells you less, i.e. you don't
know whether the list object was created as 'new SomeList<Foo>', or 'new
SomeList<Bar>', or 'new SomeList<Baz>', etc (Bar extending Foo, Baz
extending Bar).
As mentioned, which I don't think anyone is disagreeing on, all that
does is stop you from adding anything to the list - adding a Foo that
isn't a Bar would violate a potential 'new SomeList<Bar>'; adding any X
similarly fails because the object's intended element type could be a
type which X is not derived from. I think this is a consequence of<?
extends Foo> telling you /less/ than<Foo>.
Thank you, that is the point I was failing to make ;-)
The point is, a good interface should give you as little information
necessary to be useful. Returning a List<? extends Foo> allows
implementing methods to use a List<Bar> or List<Baz> as an
implementation detail, where as using List<Foo> in your interface forces
implementers to either convert, or use List<Foo> internally, which may
not be desirable. Especially if the contract of the method allows
changes to the returned list to be reflected elsewhere.
--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>