Good Design in Generics

Question

I have a design question. Below is TimeStamp Interface

/**
 * <T> Type of Timestamp. For ex: Date, long, Calendar etc
 * 
 */
public interface TimeStamp<T> extends Comparable<TimeStamp<T>>
{

  /**
   * Returns the timestamp. 
   * @return 
   */
  public T getTimeStamp();

}

I basically want to have a List class that can only contain TimeStamps. Adding anything on the list will basically depend upon the timestamp. How should be my List class declaration.

If I decide for composition, the code will look like:

public class TimeList<T> implements List<TimeStamp<T>> 
{    
  private List<TimeStamp<?>> list = new ArrayList<TimeStamp<?>>();
  //other list methods who will return based on list above
  .....
}

But the above does not make sense. For example if I have a class DefaultTimeStamp implments TimeStamp<Long> and instantiate TimeList as

TimeList<DefaultTimeStamp> l = new TimeList<DefaultTimeStamp>();

Then anycall to l.add(elem) will expect a TimeStamp<DefaultTimeStamp> which is wrong.

A declaration of: public class TimeList<TimeStamp<T>> implements List<TimeStamp<T>> would give compile time error

What should be the declaration of my TimeList<Type>? Ultimately it is just a list containing only TimeStamps

Answer 1

I don't understand why you want to do

TimeList<DefaultTimeStamp> l = new TimeList<DefaultTimeStamp>();

If you want to be able to add any kind of TimeStamp<Long>. The above way would force users to use DefaultTimeStamp if you had some implementation specific reason to do so... but usually not, obivously.

TimeList<TimeStamp<Long>> l = new TimeList<TimeStamp<Long>>();
DefaultTimeStamp dts = new DefaultTimeStamp(System.currentTimeMillis());
l.add(dts);

Should work just fine!