Re: generics:< ? >vs.< T >

Robert Klemme wrote:


I'm sure I don't know. I suppose it does keep things simpler.

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.

In lieu of 'Map<? super String, V>', a 'Map<String, V>' would be easier to
work with. You have to weigh what the extra assertion buys you. Given that
'toString()' is ubiquitous, not much. But it might be worth it - that's the
decision the designer makes.

OTOH, you need the 'extends' in another example:

<sscce source="GenericFooferol.java">
  package eegee;
  import java.util.Map;

  /** 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() );
         }
         return target;
     }

     private GenericFooferol(){}
  }
</sscce>

--
Lew
Honi soit qui mal y pense.