Re: generics:< ? >vs.< T >
Robert Klemme wrote:
Lew wrote:
But for the type of thing that you cited upthread, just a <T> is usually
better than a bounded wildcard type. Unlike types themselves, where the
advice is to generalize the declared type, for generic type parameters
it's often better to specify.
Hmm... Interesting point of view. I'll have to ponder that. My generic - err -
general position on this is to make type parameters as general as possible.
That's a very bad approach. Type parameters should assert the type
relationships you need, not be "as general as possible".
The trouble is that generalizing type assertions weakens them. <? extends
Foo> is a much weaker assertion than <Foo>, and disallows certain operations
(puts, specifically). It also doesn't let you match types:
public void foo( Bar <? extends Baz> bar, Qux <? extends Bax> qux );
allows you only very limited conclusions about the type relationships between
the base types of the two arguments. You cannot assert them to be provably
the same type. Eliminating the wildcard allows the compiler to see the guarantee.
And I apply it also to generic parameters of methods even though I readily
admit that they make things a bit complicated at times (complicated at least
for the implementer, but since I like puzzles like this it doesn't puzzle me
too much). If things get too complicated for the user of such a method I'd
definitively rethink the approach. There you have another rule of thumb of
mine: easy of use is more important than ease of writing (i.e. interface
matters).
The rule of thumb is: "Generics should assert the type relationships needed
for the code to work."
/** GenericFooferol. */
public class GenericFooferol
:-))
{
/**
* Copy a {@code Map}.
* @param <T> target value type.
* @param <S> source value type, must be a subtype of {@code T}.
* @param source {@code Map} to copy.
* @param target {@code Map} into which to copy.
* @return Map {@code <String, T>} target map.
*/
public static <T, S extends T> Map <String, T> copy(
Map <?, S> source, Map <String, T> target )
{
if ( source == null || target == null )
{
throw new IllegalArgumentException( "copy(): null argument" );
}
for ( Map.Entry <?, S> entry : source.entrySet() )
{
target.put( entry.getKey().toString(), entry.getValue() );
I'd rather
target.put( String.valueOf(entry.getKey()), entry.getValue() );
Whatever.
or
final Object key = entry.getKey();
target.put( key == null ? null : key.toString(), entry.getValue() );
NPE is such an ugly way to terminate a program. :-)0
I elided checks for runtime exceptions for simplicity of the example.
.... and because progtrammers shouldn't make such mistakes. :-)
But whatever. I wasn't writing code to copy, I was writing code to learn
from. Now they can learn from your additional comments. That plus logic
specific to their problem will make a program.
}
return target;
}
private GenericFooferol(){}
}
</sscce>
--
Lew
Honi soit qui mal y pense.