They do have a relationship, the two containers are covariant types. You
can use covariant notation, or what java calls "capture" (the ? notation
in parameter expressions) to give you a list of as much as you can tell
of the items in the list.

If you get back a list of '? extends A' it's as good as a List<A> in
that you can do whatever you could to an A, but you also know that what
is in the list is not only instance of the base type A.

import java.util.List;
import java.util.ArrayList;

public class GT
{
  public static interface A { }

  public static class B implements A { public String toString() {
return "B"; } }

  public static List<B> bees;

  public static List<? extends A> asListOfA() { return bees; }

  public static void main(String[] args)
  {
    bees = new ArrayList<B>();
    bees.add(new B());
    bees.add(new B());

    List<? extends A> as = asListOfA();

    for (A a : as)
      System.out.println(a.toString());
  }
}

--Paul Bilnoski

Make the attribute List<IntfType>.  Simple.

One line replies suck, so this is the second line.

Yes of course.
I was trying to avoid making a new List object but I've done this which is
still nice and clean:

private LinkedList<ConcreteType> attr;
public List<IntfType> getMyTypes() {
   return new ArrayList<List>(attr);
}

--
Mike W