Parametrized class into parametrizd class

Question

Hello,
I was wondering about the following: imagine you have a parametrized class SomeClass<A, B, C> with an inner (public, private or protected, doesn't matter) class, which is a collection of B-elements. Until now, I would declare SomeClass and the innter class as followed:
class SomeClass<A, B, C>
     SomeCollection coll = new SomeCollection();
     class SomeCollection extends java.util.AbstractCollection<B>
}However, while browsing through the JDK 1.5 source, I noticed the developers implement parametrized inner classes of a parametrized class as followed:
class SomeClass<A, B, C>
     SomeCollection<B> coll2 = new SomeCollection<B>();
     class SomeCollection<E> extends java.util.AbstractCollection<E>
}Is choosing between the first or the latter definition of the inner class SomeCollection a matter of personal preference, or is there a subtle difference between the two definitions? In other words, are they in every situation 100% equivalent?
I understand that one doesn't have to change the implementation of the second SomeCollection (ie. SomeCollection<D>) if he decides, for whatever reason, to have a collection of, for example, A-elements instead of B-elements (SomeCollection<B> coll2 = new SomeCollection<B>(); becomes SomeCollection<A> coll2 = new SomeCollection<A>();). Is this the only reason to prefer the second definition above the first definition?
Another example:
interface SomeInterface<X, Y>
class SomeClass<A, B, C>
     class SomeCollection extends java.util.AbstractCollection<SomeInterface<A, C>>
}thanks!

Answer 1

Thanks for your answer Bruce.
However, I think I found a difference, which hasn't anything to do with personal preference (flexibility for further use, ...) or the scoop of static classes. I'll give the code first:
class SomeClass<A, B, C, D>
     public Iterator<SomeInterface<A, B>> iterator()
          return new IteratorImpl();
     private class IteratorImpl implements Iterator<SomeInterface<A, B>>
          public boolean hasNext()
               return false;
          public SomeInterface<A, B> next()
               return null;
          public void remove()
class SomeClass<A, B, C, D>
     public Iterator<SomeInterface<A, B>> iterator()
          return new IteratorImpl<SomeInterface<A, B>>();
     private class IteratorImpl<T> implements Iterator<T>
          public boolean hasNext()
               return false;
          public T next()
               return null;
          public void remove()
}Semantically, the two fragments are identical. However, in the first fragment in the next()-function of the Iterator, there is the following type unsafety warning:
Type safety: The return type SomeInterface<A,B> of the method next() of type SomeClass<A,B, C,D>.IteratorImpl needs unchecked conversion to conform to the return type E of inherited method.
Can anybody explains this warning? IteratorImpl implements Iterator<SomeInterface<A, B>>, so why is it unsafe to have SomeInterface<A, B> as the return type of the next()-function? I don't understand this.
I noticed this while studying the JDK 1.5 source. So I would like to add another question: why did the developers leave a typesafety warning, if it can be easily fixed with the 'walk around' as given in the second fragment?
thanks,
Peter